fix(function): support multiline import type statements in import scanning (#4872)

* fix(function): support multiline import type statements in import scanning

The regex pattern `.*?` does not match newlines, causing multiline
`import type { X }` statements to be skipped during bind-mount file
scanning. This results in type-only imports not being mounted in
the Docker container, causing runtime errors like:

  worker boot error: Module not found "file:///.../types/MyType.ts"

Changed `.*?` to `[\s\S]*?` to match any character including newlines,
consistent with the `{[^{}]+}` pattern used for braced imports.

This fix enables proper handling of Deno 2.x style multiline type imports:

```typescript
import type {
  MyType,
  OtherType,
} from './types.ts'
```

Includes test case to prevent regression.

* test(function): add non-braced default type import to fixture

Cover `import type Foo from '...'` pattern in the multiline import
type test. This form also routes through the `[\s\S]*?` branch and
was previously untested.

* fix(function): use (?:type\s+)? for multiline import type matching

Narrow the regex fix for multiline import type statements per PR review feedback. Instead of widening .*? to [\s\S]*? (which affects all import patterns), add (?:type\s+)? to consume the type keyword so braced imports route into the {[^{}]+} branch that already handles newlines.

---------

Co-authored-by: Andrew Valleteau <avallete@users.noreply.github.com>

Author: lightstrike

pkg/function/deno.go

@@ -111,7 +111,7 @@ func resolveHostPath(jsonPath, hostPath string) string {
 }
 
 // Ref: https://regex101.com/r/DfBdJA/1
-var importPathPattern = regexp.MustCompile(`(?i)(?:import|export)\s+(?:{[^{}]+}|.*?)\s*(?:from)?\s*['"](.*?)['"]|import\(\s*['"](.*?)['"]\)`)
+var importPathPattern = regexp.MustCompile(`(?i)(?:import|export)\s+(?:type\s+)?(?:{[^{}]+}|.*?)\s*(?:from)?\s*['"](.*?)['"]|import\(\s*['"](.*?)['"]\)`)
 
 func (importMap *ImportMap) WalkImportPaths(srcPath string, readFile func(curr string, w io.Writer) error) error {
 	seen := map[string]struct{}{}

pkg/function/deno_test.go

@@ -86,6 +86,21 @@ func TestImportPaths(t *testing.T) {
 		assert.NoError(t, err)
 		fsys.AssertExpectations(t)
 	})
+
+	t.Run("iterates multiline import type statements", func(t *testing.T) {
+		// This test verifies that multiline import type statements are correctly parsed.
+		// The (?:type\s+)? group consumes the type keyword so braced imports hit the {[^{}]+} branch.
+		// Setup in-memory fs
+		fsys := MockFS{}
+		fsys.On("ReadFile", "testdata/modules/import_types.ts").Once()
+		fsys.On("ReadFile", "testdata/types/database.ts").Once()
+		// Run test
+		im := ImportMap{}
+		err := im.WalkImportPaths("testdata/modules/import_types.ts", fsys.ReadFile)
+		// Check error
+		assert.NoError(t, err)
+		fsys.AssertExpectations(t)
+	})
 }
 
 func TestResolveImports(t *testing.T) {

pkg/function/testdata/modules/import_types.ts

@@ -0,0 +1,22 @@
+// Test file for multiline import type statements
+// This pattern requires (?:type\s+)? to route braced imports into the {[^{}]+} branch
+
+// Multiline import type - should be matched by the regex
+import type {
+  Database,
+  Json
+} from '../types/database.ts'
+
+// Single line import type - should also work
+import type { Database as DB } from '../types/database.ts'
+
+// Re-export type to verify export pattern
+export type { Database } from '../types/database.ts'
+
+// Multiline export type
+export type {
+  Json
+} from '../types/database.ts'
+
+// Non-braced default type import - exercises the .*? branch on single-line
+import type Database from '../types/database.ts'

pkg/function/testdata/types/database.ts

@@ -0,0 +1,11 @@
+export type Database = {
+  public: {
+    Tables: {
+      users: {
+        Row: { id: string; name: string }
+      }
+    }
+  }
+}
+
+export type Json = string | number | boolean | null | { [key: string]: Json } | Json[]