poe-code 12.0.6 → 12.0.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "poe-code",
-  "version": "12.0.6",
+  "version": "12.0.7",
   "description": "CLI tool to configure Poe API for developer workflows.",
   "license": "MIT",
   "type": "module",
@@ -16,15 +16,27 @@
       "import": "./packages/memory/dist/index.js"
     },
     "./safejs": {
-      "types": "./packages/safejs/dist/index.d.ts",
+      "types": {
+        "browser": "./packages/safe-fs/dist/node-unavailable.d.ts",
+        "default": "./packages/safejs/dist/index.d.ts"
+      },
+      "browser": null,
       "import": "./packages/safejs/dist/index.js"
     },
     "./safejs/core": {
-      "types": "./packages/safejs/dist/core.d.ts",
+      "types": {
+        "browser": "./packages/safe-fs/dist/node-unavailable.d.ts",
+        "default": "./packages/safejs/dist/core.d.ts"
+      },
+      "browser": null,
       "import": "./packages/safejs/dist/core.js"
     },
     "./safejs/cli": {
-      "types": "./packages/safejs/dist/cli.d.ts",
+      "types": {
+        "browser": "./packages/safe-fs/dist/node-unavailable.d.ts",
+        "default": "./packages/safejs/dist/cli.d.ts"
+      },
+      "browser": null,
       "import": "./packages/safejs/dist/cli.js"
     },
     "./agent": {
@@ -48,8 +60,28 @@
       "import": "./dist/skills.js"
     },
     "./safe-fs": {
-      "types": "./packages/safe-fs/dist/index.d.ts",
+      "types": {
+        "browser": "./packages/safe-fs/dist/core.d.ts",
+        "default": "./packages/safe-fs/dist/index.d.ts"
+      },
+      "browser": "./packages/safejs/dist/browser/safe-fs.js",
       "import": "./packages/safejs/dist/safe-fs.js"
+    },
+    "./safe-fs/core": {
+      "types": {
+        "browser": "./packages/safe-fs/dist/core.d.ts",
+        "default": "./packages/safe-fs/dist/core.d.ts"
+      },
+      "browser": "./packages/safejs/dist/browser/safe-fs-core.js",
+      "import": "./packages/safejs/dist/safe-fs-core.js"
+    },
+    "./safe-fs/node": {
+      "types": {
+        "browser": "./packages/safe-fs/dist/node-unavailable.d.ts",
+        "default": "./packages/safe-fs/dist/node-host.d.ts"
+      },
+      "browser": null,
+      "import": "./packages/safejs/dist/safe-fs-node.js"
     }
   },
   "workspaces": [
@@ -338,5 +370,14 @@
     "ini": "5.0.0",
     "toml": "3.0.0",
     "vite": "6.4.3"
+  },
+  "imports": {
+    "#safe-fs-platform": {
+      "types": {
+        "browser": "./packages/safe-fs/dist/platform/browser.d.ts",
+        "default": "./packages/safe-fs/dist/platform/node.d.ts"
+      },
+      "default": null
+    }
   }
 }

package/packages/package-lint/dist/bundle-policy.d.ts

@@ -1,9 +1,138 @@
+export declare const canonicalFsRoutes: readonly [{
+    readonly workspace: "@poe-code/safe-fs";
+    readonly specifier: "poe-code/safe-fs";
+    readonly key: "./safe-fs";
+    readonly source: {
+        readonly node: "packages/safe-fs/src/index.ts";
+        readonly browser: "packages/safe-fs/src/core.ts";
+    };
+    readonly runtime: {
+        readonly node: "packages/safejs/dist/safe-fs.js";
+        readonly browser: "packages/safejs/dist/browser/safe-fs.js";
+    };
+    readonly types: {
+        readonly node: "packages/safe-fs/dist/index.d.ts";
+        readonly browser: "packages/safe-fs/dist/core.d.ts";
+    };
+}, {
+    readonly workspace: "@poe-code/safe-fs/core";
+    readonly specifier: "poe-code/safe-fs/core";
+    readonly key: "./safe-fs/core";
+    readonly source: {
+        readonly node: "packages/safe-fs/src/core.ts";
+        readonly browser: "packages/safe-fs/src/core.ts";
+    };
+    readonly runtime: {
+        readonly node: "packages/safejs/dist/safe-fs-core.js";
+        readonly browser: "packages/safejs/dist/browser/safe-fs-core.js";
+    };
+    readonly types: {
+        readonly node: "packages/safe-fs/dist/core.d.ts";
+        readonly browser: "packages/safe-fs/dist/core.d.ts";
+    };
+}, {
+    readonly workspace: "@poe-code/safe-fs/node";
+    readonly specifier: "poe-code/safe-fs/node";
+    readonly key: "./safe-fs/node";
+    readonly source: {
+        readonly node: "packages/safe-fs/src/node-host.ts";
+        readonly browser: null;
+    };
+    readonly runtime: {
+        readonly node: "packages/safejs/dist/safe-fs-node.js";
+        readonly browser: null;
+    };
+    readonly types: {
+        readonly node: "packages/safe-fs/dist/node-host.d.ts";
+        readonly browser: "packages/safe-fs/dist/node-unavailable.d.ts";
+    };
+}];
+export declare const canonicalFsProfiles: {
+    readonly node: {
+        readonly outdir: "packages/safejs/dist";
+        readonly policy: "packages/safe-fs/src/platform/node.ts";
+        readonly types: "packages/safe-fs/dist/platform/node.d.ts";
+    };
+    readonly browser: {
+        readonly outdir: "packages/safejs/dist/browser";
+        readonly policy: "packages/safe-fs/src/platform/browser.ts";
+        readonly types: "packages/safe-fs/dist/platform/browser.d.ts";
+    };
+};
+export declare const canonicalFsExports: {
+    [k: string]: {
+        types: {
+            browser: string;
+            default: string;
+        };
+        browser: string | null;
+        import: string;
+    };
+};
+export declare const canonicalFsTypeImports: {
+    "#safe-fs-platform": {
+        types: {
+            browser: string;
+            default: string;
+        };
+        default: null;
+    };
+};
 export declare const canonicalFs: {
-    readonly workspace: "../../safe-fs/dist/index.js";
+    readonly workspace: "@poe-code/safe-fs";
     readonly specifier: "poe-code/safe-fs";
     readonly source: "packages/safe-fs/src/index.ts";
     readonly runtime: "packages/safejs/dist/safe-fs.js";
     readonly types: "packages/safe-fs/dist/index.d.ts";
+    readonly routes: readonly [{
+        readonly workspace: "@poe-code/safe-fs";
+        readonly specifier: "poe-code/safe-fs";
+        readonly key: "./safe-fs";
+        readonly source: {
+            readonly node: "packages/safe-fs/src/index.ts";
+            readonly browser: "packages/safe-fs/src/core.ts";
+        };
+        readonly runtime: {
+            readonly node: "packages/safejs/dist/safe-fs.js";
+            readonly browser: "packages/safejs/dist/browser/safe-fs.js";
+        };
+        readonly types: {
+            readonly node: "packages/safe-fs/dist/index.d.ts";
+            readonly browser: "packages/safe-fs/dist/core.d.ts";
+        };
+    }, {
+        readonly workspace: "@poe-code/safe-fs/core";
+        readonly specifier: "poe-code/safe-fs/core";
+        readonly key: "./safe-fs/core";
+        readonly source: {
+            readonly node: "packages/safe-fs/src/core.ts";
+            readonly browser: "packages/safe-fs/src/core.ts";
+        };
+        readonly runtime: {
+            readonly node: "packages/safejs/dist/safe-fs-core.js";
+            readonly browser: "packages/safejs/dist/browser/safe-fs-core.js";
+        };
+        readonly types: {
+            readonly node: "packages/safe-fs/dist/core.d.ts";
+            readonly browser: "packages/safe-fs/dist/core.d.ts";
+        };
+    }, {
+        readonly workspace: "@poe-code/safe-fs/node";
+        readonly specifier: "poe-code/safe-fs/node";
+        readonly key: "./safe-fs/node";
+        readonly source: {
+            readonly node: "packages/safe-fs/src/node-host.ts";
+            readonly browser: null;
+        };
+        readonly runtime: {
+            readonly node: "packages/safejs/dist/safe-fs-node.js";
+            readonly browser: null;
+        };
+        readonly types: {
+            readonly node: "packages/safe-fs/dist/node-host.d.ts";
+            readonly browser: "packages/safe-fs/dist/node-unavailable.d.ts";
+        };
+    }];
 };
 export interface BundleMetafile {
     inputs?: Record<string, unknown>;
@@ -21,6 +150,12 @@ export interface BundleMetafile {
         entryPoints: string[];
         metafile: BundleMetafile;
     };
+    browserCanonicalBundle?: {
+        entryPoints: string[];
+        metafile: BundleMetafile;
+    };
+    canonicalTypes?: Record<string, string[]>;
+    canonicalEmptyTypes?: string[];
 }
 export interface BundleIssue {
     external: string;
@@ -29,10 +164,18 @@ export interface BundleIssue {
 interface PackageManifest {
     name: string;
     exports?: unknown;
+    imports?: unknown;
     dependencies?: Record<string, string>;
     optionalDependencies?: Record<string, string>;
 }
 export declare function findBundleIssues(manifest: PackageManifest, workspaceNames: ReadonlySet<string>, metafile: BundleMetafile, packedFiles: ReadonlySet<string>): BundleIssue[];
+export declare function collectCanonicalDeclarations(rootDir: string, files: {
+    readdir(filename: string): Promise<{
+        name: string;
+        isDirectory(): boolean;
+    }[]>;
+    readFile(filename: string): Promise<string>;
+}): Promise<Pick<BundleMetafile, "canonicalTypes" | "canonicalEmptyTypes">>;
 export declare function collectPackageFiles(rootDir: string, entries: readonly string[], files: {
     readdir(filename: string): Promise<{
         name: string;

package/packages/package-lint/dist/bundle-policy.js

@@ -1,11 +1,91 @@
 import { isBuiltin } from "node:module";
 import path from "node:path";
+export const canonicalFsRoutes = [
+    {
+        workspace: "@poe-code/safe-fs",
+        specifier: "poe-code/safe-fs",
+        key: "./safe-fs",
+        source: { node: "packages/safe-fs/src/index.ts", browser: "packages/safe-fs/src/core.ts" },
+        runtime: {
+            node: "packages/safejs/dist/safe-fs.js",
+            browser: "packages/safejs/dist/browser/safe-fs.js"
+        },
+        types: { node: "packages/safe-fs/dist/index.d.ts", browser: "packages/safe-fs/dist/core.d.ts" }
+    },
+    {
+        workspace: "@poe-code/safe-fs/core",
+        specifier: "poe-code/safe-fs/core",
+        key: "./safe-fs/core",
+        source: { node: "packages/safe-fs/src/core.ts", browser: "packages/safe-fs/src/core.ts" },
+        runtime: {
+            node: "packages/safejs/dist/safe-fs-core.js",
+            browser: "packages/safejs/dist/browser/safe-fs-core.js"
+        },
+        types: { node: "packages/safe-fs/dist/core.d.ts", browser: "packages/safe-fs/dist/core.d.ts" }
+    },
+    {
+        workspace: "@poe-code/safe-fs/node",
+        specifier: "poe-code/safe-fs/node",
+        key: "./safe-fs/node",
+        source: { node: "packages/safe-fs/src/node-host.ts", browser: null },
+        runtime: { node: "packages/safejs/dist/safe-fs-node.js", browser: null },
+        types: {
+            node: "packages/safe-fs/dist/node-host.d.ts",
+            browser: "packages/safe-fs/dist/node-unavailable.d.ts"
+        }
+    }
+];
+export const canonicalFsProfiles = {
+    node: {
+        outdir: "packages/safejs/dist",
+        policy: "packages/safe-fs/src/platform/node.ts",
+        types: "packages/safe-fs/dist/platform/node.d.ts"
+    },
+    browser: {
+        outdir: "packages/safejs/dist/browser",
+        policy: "packages/safe-fs/src/platform/browser.ts",
+        types: "packages/safe-fs/dist/platform/browser.d.ts"
+    }
+};
+export const canonicalFsExports = Object.fromEntries(canonicalFsRoutes.map((route) => [
+    route.key,
+    {
+        types: { browser: `./${route.types.browser}`, default: `./${route.types.node}` },
+        browser: route.runtime.browser === null ? null : `./${route.runtime.browser}`,
+        import: `./${route.runtime.node}`
+    }
+]));
+const nodeOnlySafeJsExports = Object.fromEntries([
+    ["./safejs", "index"],
+    ["./safejs/core", "core"],
+    ["./safejs/cli", "cli"]
+].map(([route, entry]) => [
+    route,
+    {
+        types: {
+            browser: "./packages/safe-fs/dist/node-unavailable.d.ts",
+            default: `./packages/safejs/dist/${entry}.d.ts`
+        },
+        browser: null,
+        import: `./packages/safejs/dist/${entry}.js`
+    }
+]));
+export const canonicalFsTypeImports = {
+    "#safe-fs-platform": {
+        types: {
+            browser: `./${canonicalFsProfiles.browser.types}`,
+            default: `./${canonicalFsProfiles.node.types}`
+        },
+        default: null
+    }
+};
 export const canonicalFs = {
     workspace: "@poe-code/safe-fs",
     specifier: "poe-code/safe-fs",
     source: "packages/safe-fs/src/index.ts",
     runtime: "packages/safejs/dist/safe-fs.js",
-    types: "packages/safe-fs/dist/index.d.ts"
+    types: "packages/safe-fs/dist/index.d.ts",
+    routes: canonicalFsRoutes
 };
 function record(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value)
@@ -31,7 +111,8 @@ function packageName(specifier) {
 }
 export function findBundleIssues(manifest, workspaceNames, metafile, packedFiles) {
     const issues = [];
-    const exported = record(record(manifest.exports)["./safe-fs"]);
+    const exported = record(manifest.exports);
+    const routes = new Set(canonicalFsRoutes.map((route) => route.specifier));
     const imports = new Set(Object.values(metafile.outputs ?? {}).flatMap((output) => (output.imports ?? [])
         .filter((dependency) => dependency.external)
         .map((dependency) => dependency.path ?? "")));
@@ -42,7 +123,7 @@ export function findBundleIssues(manifest, workspaceNames, metafile, packedFiles
     for (const specifier of [...imports].sort()) {
         if (isBuiltin(specifier))
             continue;
-        if (specifier === canonicalFs.specifier && manifest.name === "poe-code")
+        if (routes.has(specifier) && manifest.name === "poe-code")
             continue;
         const dependency = packageName(specifier);
         const reason = !dependency
@@ -55,79 +136,227 @@ export function findBundleIssues(manifest, workspaceNames, metafile, packedFiles
         if (reason)
             issues.push({ external: specifier, reason });
     }
+    const exportKeys = Object.keys(exported).filter((key) => key === "./safe-fs" || key.startsWith("./safe-fs/"));
     if (!metafile.canonicalBundle &&
-        !imports.has(canonicalFs.specifier) &&
-        !Object.keys(exported).length)
+        !metafile.browserCanonicalBundle &&
+        !exportKeys.length &&
+        ![...imports].some((specifier) => routes.has(specifier)))
         return issues;
-    const fail = (reason) => issues.push({ external: canonicalFs.specifier, reason });
-    if (manifest.name !== "poe-code" ||
-        exported.import !== `./${canonicalFs.runtime}` ||
-        exported.types !== `./${canonicalFs.types}` ||
-        Object.keys(exported).some((condition) => condition !== "import" && condition !== "types")) {
+    const fail = (reason, external = canonicalFs.specifier) => {
+        if (!issues.some((issue) => issue.external === external && issue.reason === reason))
+            issues.push({ external, reason });
+    };
+    for (const route of canonicalFsRoutes) {
+        if (manifest.name !== "poe-code" ||
+            JSON.stringify(exported[route.key]) !== JSON.stringify(canonicalFsExports[route.key]))
+            fail("invalid-canonical-export", route.specifier);
+    }
+    if (exportKeys.some((key) => !canonicalFsRoutes.some((route) => route.key === key)))
         fail("invalid-canonical-export");
+    for (const [key, expected] of Object.entries(nodeOnlySafeJsExports)) {
+        if (JSON.stringify(exported[key]) !== JSON.stringify(expected))
+            fail("invalid-node-only-safejs-export", `poe-code${key.slice(1)}`);
+    }
+    if (JSON.stringify(record(manifest.imports)["#safe-fs-platform"]) !==
+        JSON.stringify(canonicalFsTypeImports["#safe-fs-platform"]))
+        fail("invalid-canonical-type-import");
+    const canonicalPaths = canonicalFsRoutes
+        .flatMap((route) => [...Object.values(route.runtime), ...Object.values(route.types)])
+        .filter((filename) => filename !== null);
+    for (const filename of canonicalPaths) {
+        let directory = path.posix.dirname(filename);
+        while (directory !== ".") {
+            if (packedFiles.has(`${directory}/package.json`))
+                fail("nested-canonical-package-scope");
+            directory = path.posix.dirname(directory);
+        }
     }
-    if (!packedFiles.has(canonicalFs.types))
-        fail("unpacked-canonical-types");
     if ([...packedFiles].some((filename) => filename.startsWith("packages/safe-fs/dist/") &&
         [".js", ".mjs", ".cjs"].some((extension) => filename.endsWith(extension))))
         fail("duplicate-packed-runtime");
-    if (Object.keys(metafile.inputs ?? {}).some((input) => input.startsWith("packages/safe-fs/src/"))) {
+    if (Object.keys(metafile.inputs ?? {}).some((input) => input.startsWith("packages/safe-fs/src/")))
         fail("duplicate-canonical-runtime");
-    }
-    const canonical = metafile.canonicalBundle;
-    if (!canonical ||
-        !Array.isArray(canonical.entryPoints) ||
-        !canonical.entryPoints.includes(canonicalFs.source)) {
-        fail("missing-canonical-root");
-        return issues;
-    }
-    const outputs = canonical.metafile.outputs ?? {};
-    if (!Object.hasOwn(canonical.metafile.inputs ?? {}, canonicalFs.source))
-        fail("missing-canonical-source");
-    if (outputs[canonicalFs.runtime]?.entryPoint !== canonicalFs.source)
-        fail("invalid-canonical-root");
-    for (const entry of canonical.entryPoints) {
-        if (!Object.values(outputs).some((output) => output.entryPoint === entry))
-            fail("missing-declared-root");
-    }
-    const pending = [canonicalFs.runtime];
-    const visited = new Set();
-    while (pending.length) {
-        const filename = pending.pop();
-        if (visited.has(filename))
-            continue;
-        visited.add(filename);
-        if (!filename.startsWith("packages/safejs/dist/") ||
-            path.posix.normalize(filename) !== filename) {
-            fail("invalid-canonical-path");
+    const emptyTypes = "packages/safe-fs/dist/node-unavailable.d.ts";
+    if (!metafile.canonicalEmptyTypes?.includes(emptyTypes))
+        fail("nonempty-browser-node-types", "poe-code/safe-fs/node");
+    for (const profile of ["node", "browser"]) {
+        const settings = canonicalFsProfiles[profile];
+        const canonical = profile === "node" ? metafile.canonicalBundle : metafile.browserCanonicalBundle;
+        if (!canonical || !Array.isArray(canonical.entryPoints)) {
+            fail("missing-canonical-root");
             continue;
         }
-        const output = outputs[filename];
-        if (!output) {
-            fail("missing-canonical-output");
-            continue;
+        const inputs = canonical.metafile.inputs ?? {};
+        if (!Object.hasOwn(inputs, settings.policy) ||
+            Object.hasOwn(inputs, canonicalFsProfiles[profile === "node" ? "browser" : "node"].policy))
+            fail("wrong-canonical-policy");
+        const outputs = canonical.metafile.outputs ?? {};
+        for (const singleton of [
+            "contracts/errors.ts",
+            "bridge/filesystem.ts",
+            "fs/memory/index.ts",
+            "fs/mount/comparison.ts",
+            "fs/s3/registry.ts",
+            "fs/s3/authority.ts",
+            `platform/${profile}.ts`
+        ]) {
+            const source = `packages/safe-fs/src/${singleton}`;
+            if (!Object.hasOwn(inputs, source))
+                continue;
+            const copies = Object.entries(outputs).filter(([filename, output]) => packedFiles.has(filename) && Object.hasOwn(output.inputs ?? {}, source));
+            if (copies.length > 1)
+                fail("duplicate-canonical-singleton");
+        }
+        const pending = [];
+        for (const route of canonicalFsRoutes) {
+            const source = route.source[profile];
+            const runtime = route.runtime[profile];
+            if (source === null || runtime === null)
+                continue;
+            if (!canonical.entryPoints.includes(source))
+                fail("missing-canonical-root", route.specifier);
+            if (!Object.hasOwn(inputs, source))
+                fail("missing-canonical-source", route.specifier);
+            if (outputs[runtime]?.entryPoint !== source)
+                fail("invalid-canonical-root", route.specifier);
+            pending.push(runtime);
+        }
+        for (const entry of canonical.entryPoints) {
+            if (!Object.values(outputs).some((output) => output.entryPoint === entry))
+                fail("missing-declared-root");
         }
-        if (!packedFiles.has(filename))
-            fail("unpacked-canonical-output");
-        if (filename.endsWith(".js"))
-            pending.push(`${filename}.map`);
-        if (Object.keys(output.inputs ?? {}).some((input) => !input.startsWith("packages/safe-fs/src/")))
-            fail("foreign-canonical-input");
-        if (output.cssBundle)
-            pending.push(output.cssBundle);
-        for (const dependency of output.imports ?? []) {
-            if (dependency.external) {
-                if (!dependency.path || !isBuiltin(dependency.path))
-                    fail("external-canonical-dependency");
+        const rootedOutputs = new Set();
+        const rootedPending = Object.entries(outputs)
+            .filter(([, output]) => output.entryPoint && canonical.entryPoints.includes(output.entryPoint))
+            .map(([filename]) => filename);
+        while (rootedPending.length) {
+            const filename = rootedPending.pop();
+            if (rootedOutputs.has(filename))
+                continue;
+            rootedOutputs.add(filename);
+            for (const dependency of outputs[filename]?.imports ?? []) {
+                if (!dependency.external && dependency.path)
+                    rootedPending.push(dependency.path);
+            }
+        }
+        for (const [filename, output] of Object.entries(outputs)) {
+            if (output.entryPoint && !rootedOutputs.has(filename) && packedFiles.has(filename))
+                fail("undeclared-canonical-root");
+        }
+        const visited = new Set();
+        while (pending.length) {
+            const filename = pending.pop();
+            if (visited.has(filename))
+                continue;
+            visited.add(filename);
+            if (!filename.startsWith(`${settings.outdir}/`) ||
+                path.posix.normalize(filename) !== filename ||
+                (profile === "node" && filename.startsWith(`${canonicalFsProfiles.browser.outdir}/`))) {
+                fail("invalid-canonical-path");
+                continue;
+            }
+            const output = outputs[filename];
+            if (!output) {
+                fail("missing-canonical-output");
+                continue;
+            }
+            if (!packedFiles.has(filename))
+                fail("unpacked-canonical-output");
+            if (filename.endsWith(".js"))
+                pending.push(`${filename}.map`);
+            if (Object.keys(output.inputs ?? {}).some((input) => !input.startsWith("packages/safe-fs/src/")))
+                fail("foreign-canonical-input");
+            if (output.cssBundle)
+                pending.push(output.cssBundle);
+            for (const dependency of output.imports ?? []) {
+                if (dependency.external) {
+                    if (profile === "browser" || !dependency.path || !isBuiltin(dependency.path))
+                        fail("external-canonical-dependency");
+                }
+                else if (dependency.path)
+                    pending.push(dependency.path);
+                else
+                    fail("missing-canonical-edge");
+            }
+        }
+        const typeQueue = canonicalFsRoutes.map((route) => route.types[profile]);
+        typeQueue.push(settings.types);
+        const seenTypes = new Set();
+        while (typeQueue.length) {
+            const filename = typeQueue.pop();
+            if (seenTypes.has(filename))
+                continue;
+            seenTypes.add(filename);
+            if (!filename.startsWith("packages/safe-fs/dist/") ||
+                path.posix.normalize(filename) !== filename ||
+                !filename.endsWith(".d.ts")) {
+                fail("invalid-canonical-types-path");
+                continue;
+            }
+            if (!packedFiles.has(filename))
+                fail("unpacked-canonical-types");
+            const edges = metafile.canonicalTypes?.[filename];
+            if (!Array.isArray(edges)) {
+                fail("missing-canonical-types");
+                continue;
+            }
+            for (const edge of edges) {
+                if (edge === "#safe-fs-platform")
+                    typeQueue.push(settings.types);
+                else if (isBuiltin(edge)) {
+                    if (profile === "browser")
+                        fail("external-canonical-types");
+                }
+                else if (edge.startsWith(".") &&
+                    !["?", "#", "%", "\\", ":"].some((character) => edge.includes(character)) &&
+                    (edge.endsWith(".js") || edge.endsWith(".d.ts"))) {
+                    const target = edge.endsWith(".js") ? `${edge.slice(0, -3)}.d.ts` : edge;
+                    typeQueue.push(path.posix.normalize(path.posix.join(path.posix.dirname(filename), target)));
+                }
+                else
+                    fail("external-canonical-types");
             }
-            else if (dependency.path)
-                pending.push(dependency.path);
-            else
-                fail("missing-canonical-edge");
         }
     }
     return issues;
 }
+export async function collectCanonicalDeclarations(rootDir, files) {
+    const { default: ts } = await import("typescript");
+    const declarations = await collectPackageFiles(rootDir, ["packages/safe-fs/dist/**/*.d.ts"], files);
+    const canonicalTypes = {};
+    const canonicalEmptyTypes = [];
+    for (const filename of declarations) {
+        const source = ts.createSourceFile(filename, await files.readFile(path.join(rootDir, filename)), ts.ScriptTarget.Latest, true);
+        const imports = new Set(source.referencedFiles.map((reference) => reference.fileName));
+        const visit = (node) => {
+            if ((ts.isImportDeclaration(node) || ts.isExportDeclaration(node)) &&
+                node.moduleSpecifier &&
+                ts.isStringLiteral(node.moduleSpecifier))
+                imports.add(node.moduleSpecifier.text);
+            if (ts.isImportTypeNode(node) &&
+                ts.isLiteralTypeNode(node.argument) &&
+                ts.isStringLiteral(node.argument.literal))
+                imports.add(node.argument.literal.text);
+            if (ts.isExternalModuleReference(node) &&
+                node.expression &&
+                ts.isStringLiteral(node.expression))
+                imports.add(node.expression.text);
+            ts.forEachChild(node, visit);
+        };
+        visit(source);
+        for (const reference of source.typeReferenceDirectives)
+            imports.add(`types:${reference.fileName}`);
+        canonicalTypes[filename] = [...imports];
+        if (source.statements.length === 1 &&
+            source.statements.every((statement) => ts.isExportDeclaration(statement) &&
+                !statement.moduleSpecifier &&
+                statement.exportClause &&
+                ts.isNamedExports(statement.exportClause) &&
+                statement.exportClause.elements.length === 0))
+            canonicalEmptyTypes.push(filename);
+    }
+    return { canonicalTypes, canonicalEmptyTypes };
+}
 export async function collectPackageFiles(rootDir, entries, files) {
     const packed = new Set();
     async function visit(filename, declarationsOnly) {

package/packages/package-lint/dist/model.d.ts

@@ -1,4 +1,4 @@
-import type { BundleMetafile } from "./bundle-policy.js";
+import { type BundleMetafile } from "./bundle-policy.js";
 import { type PackageFileView, type PacklistProvider } from "./packlist.js";
 import { type RuntimeAssetDeclaration, type RuntimeFileAssetView } from "./runtime-files.js";
 import { type SourceImportView } from "./source-imports.js";
@@ -40,6 +40,7 @@ export interface PackageInfo {
     ecosystem: Ecosystem;
     main: string | undefined;
     exports: unknown;
+    imports?: unknown;
     bin: Record<string, string>;
     files: string[];
     scripts: Record<string, string>;