@intentic/extension-manifest 1.317.0 → 1.319.0

package/dist/points/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/points/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AACxC,OAAO,EAAE,wBAAwB,EAAE,MAAM,2BAA2B,CAAC;AACrE,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AACpC,OAAO,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AACtD,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAC9C,OAAO,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAChD,OAAO,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AACxC,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAC9C,OAAO,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAChD,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAC9C,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AACxC,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAC5C,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAExC,cAAc,YAAY,CAAC;AAC3B,cAAc,2BAA2B,CAAC;AAC1C,cAAc,UAAU,CAAC;AACzB,cAAc,mBAAmB,CAAC;AAClC,cAAc,eAAe,CAAC;AAC9B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,kBAAkB,CAAC;AACjC,cAAc,YAAY,CAAC;AAC3B,cAAc,eAAe,CAAC;AAC9B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,eAAe,CAAC;AAC9B,cAAc,YAAY,CAAC;AAC3B,cAAc,cAAc,CAAC;AAC7B,cAAc,YAAY,CAAC;AAK3B,MAAM,CAAC,MAAM,mBAAmB,GAAG;IAC/B,UAAU;IACV,UAAU;IACV,YAAY;IACZ,cAAc;IACd,aAAa;IACb,aAAa;IACb,cAAc;IACd,UAAU;IACV,gBAAgB;IAChB,iBAAiB;IACjB,aAAa;IACb,wBAAwB;IACxB,QAAQ;IACR,UAAU;CACmC,CAAC;AAUlD,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAAC,CAAC,MAAM,CACrC,MAAM,CAAC,WAAW,CAAC,mBAAmB,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC,KAAK,CAAC,IAAI,EAAE,KAAK,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAqB,CAChJ,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/points/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AACxC,OAAO,EAAE,wBAAwB,EAAE,MAAM,2BAA2B,CAAC;AACrE,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AACpC,OAAO,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AACtD,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAC9C,OAAO,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAChD,OAAO,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AACxC,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAC9C,OAAO,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAChD,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAC9C,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AACjD,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AACxC,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAC5C,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAExC,cAAc,YAAY,CAAC;AAC3B,cAAc,2BAA2B,CAAC;AAC1C,cAAc,UAAU,CAAC;AACzB,cAAc,mBAAmB,CAAC;AAClC,cAAc,eAAe,CAAC;AAC9B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,kBAAkB,CAAC;AACjC,cAAc,YAAY,CAAC;AAC3B,cAAc,eAAe,CAAC;AAC9B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,eAAe,CAAC;AAC9B,cAAc,iBAAiB,CAAC;AAChC,cAAc,YAAY,CAAC;AAC3B,cAAc,cAAc,CAAC;AAC7B,cAAc,YAAY,CAAC;AAK3B,MAAM,CAAC,MAAM,mBAAmB,GAAG;IAC/B,UAAU;IACV,UAAU;IACV,YAAY;IACZ,cAAc;IACd,cAAc;IACd,aAAa;IACb,aAAa;IACb,cAAc;IACd,UAAU;IACV,gBAAgB;IAChB,iBAAiB;IACjB,aAAa;IACb,wBAAwB;IACxB,QAAQ;IACR,UAAU;CACmC,CAAC;AAUlD,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAAC,CAAC,MAAM,CACrC,MAAM,CAAC,WAAW,CAAC,mBAAmB,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC,KAAK,CAAC,IAAI,EAAE,KAAK,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAqB,CAChJ,CAAC"}

package/dist/points/side-views.d.ts

@@ -0,0 +1,17 @@
+import { z } from "zod";
+export declare const SideViewContributionSchema: z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodString;
+    links: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type SideViewContribution = z.infer<typeof SideViewContributionSchema>;
+export declare const sideViewsPoint: {
+    readonly name: "sideViews";
+    readonly description: "Things this extension can show in the editor's side panel, one input at a time, beside whatever the reader is doing. Each entry reserves an id; the extension supplies the component with api.sideViews.register and opens one with api.sideViews.open, and the host refuses any id this list does not cover.";
+    readonly schema: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        links: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+};
+//# sourceMappingURL=side-views.d.ts.map

package/dist/points/side-views.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"side-views.d.ts","sourceRoot":"","sources":["../../src/points/side-views.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,0BAA0B;;;;iBAmByD,CAAC;AACjG,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAE9E,eAAO,MAAM,cAAc;mBACjB,WAAW;0BAEb,+SAA+S;;;;;;CAEjR,CAAC"}

package/dist/points/side-views.js

@@ -0,0 +1,20 @@
+import { z } from "zod";
+export const SideViewContributionSchema = z.object({
+    id: z.string().regex(/^[a-z0-9][a-z0-9-]*$/),
+    label: z
+        .string()
+        .min(1)
+        .describe("What one of these is called (\"CI run\"), shown in the install dialog and on a tab whose own title could not be read. Each tab's title is the extension's to say for the thing it shows."),
+    links: z
+        .boolean()
+        .optional()
+        .describe("Allow this side view to take links the chat renders: a link it recognises (its registration's `claim`) opens beside the chat instead of in a new browser tab. Declared because it changes what the reader's click does; leave it out and the host never asks.")
+        .meta({ power: { key: "side-view-links:${id}", sentence: 'opens links it recognises as "${label}" beside the chat' } }),
+})
+    .meta({ power: { key: "side-view:${id}", sentence: 'shows "${label}" in the side panel' } });
+export const sideViewsPoint = {
+    name: "sideViews",
+    description: "Things this extension can show in the editor's side panel, one input at a time, beside whatever the reader is doing. Each entry reserves an id; the extension supplies the component with api.sideViews.register and opens one with api.sideViews.open, and the host refuses any id this list does not cover.",
+    schema: z.array(SideViewContributionSchema),
+};
+//# sourceMappingURL=side-views.js.map

package/dist/points/side-views.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"side-views.js","sourceRoot":"","sources":["../../src/points/side-views.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,MAAM,CAAC,MAAM,0BAA0B,GAAG,CAAC,CAAC,MAAM,CAAC;IAC/C,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,KAAK,CAAC,sBAAsB,CAAC;IAC5C,KAAK,EAAE,CAAC;SACH,MAAM,EAAE;SACR,GAAG,CAAC,CAAC,CAAC;SACN,QAAQ,CACL,0LAA0L,CAC7L;IAIL,KAAK,EAAE,CAAC;SACH,OAAO,EAAE;SACT,QAAQ,EAAE;SACV,QAAQ,CACL,+PAA+P,CAClQ;SACA,IAAI,CAAC,EAAE,KAAK,EAAE,EAAE,GAAG,EAAE,uBAAuB,EAAE,QAAQ,EAAE,yDAAyD,EAAE,EAAE,CAAC;CAC9H,CAAC;KACG,IAAI,CAAC,EAAE,KAAK,EAAE,EAAE,GAAG,EAAE,iBAAiB,EAAE,QAAQ,EAAE,oCAAoC,EAAE,EAAE,CAAC,CAAC;AAGjG,MAAM,CAAC,MAAM,cAAc,GAAG;IAC1B,IAAI,EAAE,WAAW;IACjB,WAAW,EACP,+SAA+S;IACnT,MAAM,EAAE,CAAC,CAAC,KAAK,CAAC,0BAA0B,CAAC;CACT,CAAC"}

package/dist/points/viewers.js

@@ -7,7 +7,7 @@ export const ViewerContributionSchema = z.object({
         .describe('Bare file extensions, no dot: e.g. ["docx", "xlsx"].'),
     fetch: z
         .enum(["text", "blob", "url", "path"])
-        .describe("How much of the file the host hands you. `text` for a format that is text (svg, a subtitle track). `blob` for one that must be parsed end to end before any of it shows (a .docx, a spreadsheet), bounded by the daemon's raw-read cap. `url` for anything range-read rather than parsed (audio, video): your component gets a streaming URL to point an element at, never the bytes. `path` for a viewer whose own backend reads and writes the file: you get the workspace path and the scope it is viewed in, nothing else."),
+        .describe("How much of the file the host hands you. `text` for a format that is text (svg, a subtitle track). `blob` for one that must be parsed end to end before any of it shows (a .docx, a spreadsheet), bounded by the daemon's raw-read cap. `url` for anything range-read rather than parsed (audio, video): your component gets a streaming URL to point an element at, never the bytes. `path` for a viewer whose own backend reads and writes the file: you get the workspace path and the scope it is viewed in, plus `readOnly` where the window may not write the file and, in a desktop app's local window, a `text` slot holding the document's text for while your own view can't show it. Emit `dirty` (a boolean) whenever you start or stop holding edits the file doesn't have, so a window closing over them can ask first."),
     edit: z
         .boolean()
         .optional()

package/dist/points/viewers.js.map

@@ -1 +1 @@
-{"version":3,"file":"viewers.js","sourceRoot":"","sources":["../../src/points/viewers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,MAAM,CAAC,MAAM,wBAAwB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC7C,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,KAAK,CAAC,sBAAsB,CAAC;IAC5C,UAAU,EAAE,CAAC;SACR,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,KAAK,CAAC,aAAa,CAAC,CAAC;SACtC,GAAG,CAAC,CAAC,CAAC;SACN,QAAQ,CAAC,sDAAsD,CAAC;IASrE,KAAK,EAAE,CAAC;SACH,IAAI,CAAC,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,CAAC,CAAC;SACrC,QAAQ,CACL,ggBAAggB,CACngB;IAGL,IAAI,EAAE,CAAC;SACF,OAAO,EAAE;SACT,QAAQ,EAAE;SACV,QAAQ,CACL,mKAAmK,CACtK;IAGL,OAAO,EAAE,CAAC;SACL,OAAO,EAAE;SACT,QAAQ,EAAE;SACV,QAAQ,CACL,oOAAoO,CACvO;CACR,CAAC;KACG,IAAI,CAAC,EAAE,KAAK,EAAE,EAAE,GAAG,EAAE,cAAc,EAAE,QAAQ,EAAE,4FAA4F,EAAE,EAAE,CAAC,CAAC;AAGtJ,MAAM,CAAC,MAAM,YAAY,GAAG;IACxB,IAAI,EAAE,SAAS;IACf,WAAW,EACP,6OAA6O;IACjP,MAAM,EAAE,CAAC,CAAC,KAAK,CAAC,wBAAwB,CAAC;CACP,CAAC"}
+{"version":3,"file":"viewers.js","sourceRoot":"","sources":["../../src/points/viewers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,MAAM,CAAC,MAAM,wBAAwB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC7C,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,KAAK,CAAC,sBAAsB,CAAC;IAC5C,UAAU,EAAE,CAAC;SACR,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,KAAK,CAAC,aAAa,CAAC,CAAC;SACtC,GAAG,CAAC,CAAC,CAAC;SACN,QAAQ,CAAC,sDAAsD,CAAC;IASrE,KAAK,EAAE,CAAC;SACH,IAAI,CAAC,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,CAAC,CAAC;SACrC,QAAQ,CACL,uyBAAuyB,CAC1yB;IAGL,IAAI,EAAE,CAAC;SACF,OAAO,EAAE;SACT,QAAQ,EAAE;SACV,QAAQ,CACL,mKAAmK,CACtK;IAGL,OAAO,EAAE,CAAC;SACL,OAAO,EAAE;SACT,QAAQ,EAAE;SACV,QAAQ,CACL,oOAAoO,CACvO;CACR,CAAC;KACG,IAAI,CAAC,EAAE,KAAK,EAAE,EAAE,GAAG,EAAE,cAAc,EAAE,QAAQ,EAAE,4FAA4F,EAAE,EAAE,CAAC,CAAC;AAGtJ,MAAM,CAAC,MAAM,YAAY,GAAG;IACxB,IAAI,EAAE,SAAS;IACf,WAAW,EACP,6OAA6O;IACjP,MAAM,EAAE,CAAC,CAAC,KAAK,CAAC,wBAAwB,CAAC;CACP,CAAC"}

package/intentic-extension.schema.json

@@ -204,7 +204,7 @@
                                     "url",
                                     "path"
                                 ],
-                                "description": "How much of the file the host hands you. `text` for a format that is text (svg, a subtitle track). `blob` for one that must be parsed end to end before any of it shows (a .docx, a spreadsheet), bounded by the daemon's raw-read cap. `url` for anything range-read rather than parsed (audio, video): your component gets a streaming URL to point an element at, never the bytes. `path` for a viewer whose own backend reads and writes the file: you get the workspace path and the scope it is viewed in, nothing else."
+                                "description": "How much of the file the host hands you. `text` for a format that is text (svg, a subtitle track). `blob` for one that must be parsed end to end before any of it shows (a .docx, a spreadsheet), bounded by the daemon's raw-read cap. `url` for anything range-read rather than parsed (audio, video): your component gets a streaming URL to point an element at, never the bytes. `path` for a viewer whose own backend reads and writes the file: you get the workspace path and the scope it is viewed in, plus `readOnly` where the window may not write the file and, in a desktop app's local window, a `text` slot holding the document's text for while your own view can't show it. Emit `dirty` (a boolean) whenever you start or stop holding edits the file doesn't have, so a window closing over them can ask first."
                             },
                             "edit": {
                                 "description": "Whether this viewer writes the file back. An editing viewer is chosen over a render-only viewer claiming the same extension, whatever order the two activated in.",
@@ -255,6 +255,41 @@
                     },
                     "description": "Per-directory documents this extension can offer. Your provider marks the rows in the Workspace tree it has something to say about, and the host opens your component as a tab."
                 },
+                "sideViews": {
+                    "type": "array",
+                    "items": {
+                        "type": "object",
+                        "properties": {
+                            "id": {
+                                "type": "string",
+                                "pattern": "^[a-z0-9][a-z0-9-]*$"
+                            },
+                            "label": {
+                                "type": "string",
+                                "minLength": 1,
+                                "description": "What one of these is called (\"CI run\"), shown in the install dialog and on a tab whose own title could not be read. Each tab's title is the extension's to say for the thing it shows."
+                            },
+                            "links": {
+                                "description": "Allow this side view to take links the chat renders: a link it recognises (its registration's `claim`) opens beside the chat instead of in a new browser tab. Declared because it changes what the reader's click does; leave it out and the host never asks.",
+                                "power": {
+                                    "key": "side-view-links:${id}",
+                                    "sentence": "opens links it recognises as \"${label}\" beside the chat"
+                                },
+                                "type": "boolean"
+                            }
+                        },
+                        "required": [
+                            "id",
+                            "label"
+                        ],
+                        "power": {
+                            "key": "side-view:${id}",
+                            "sentence": "shows \"${label}\" in the side panel"
+                        },
+                        "additionalProperties": false
+                    },
+                    "description": "Things this extension can show in the editor's side panel, one input at a time, beside whatever the reader is doing. Each entry reserves an id; the extension supplies the component with api.sideViews.register and opens one with api.sideViews.open, and the host refuses any id this list does not cover."
+                },
                 "commands": {
                     "type": "array",
                     "items": {
@@ -687,6 +722,14 @@
                                         ],
                                         "additionalProperties": false
                                     },
+                                    "hosts": {
+                                        "description": "The hosts this card's credential is meant for, as templates over the fields like `env` (`api.github.com`, `*.githubusercontent.com`, `${url}`); a value that comes out as a URL counts as its host. The sandbox limits the credential's `{{secret:…}}` reference to them by default, so a use aimed anywhere else asks a person first. The owner can change or lift the list on the Secrets view.",
+                                        "type": "array",
+                                        "items": {
+                                            "type": "string",
+                                            "minLength": 1
+                                        }
+                                    },
                                     "mcp": {
                                         "description": "Deprecated: declare `contributes.tools` with `perCard` naming this card instead, and serve the tools with `api.tools.serve`. A path in this extension's backend (`server`) answering MCP over Streamable HTTP; every turn granted a card of this kind gets it as a server named by the card's id, each request arriving at `<path>/<card id>`.",
                                         "effect": "mcp",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intentic/extension-manifest",
-  "version": "1.317.0",
+  "version": "1.319.0",
   "description": "What an intentic extension DECLARES, the intentic-extension.json schema and the sandbox-route allowlist rule",
   "license": "MIT",
   "type": "module",
@@ -32,18 +32,23 @@
     }
   },
   "dependencies": {
-    "@intentic/base": "1.317.0",
+    "@intentic/base": "1.319.0",
     "tslib": "2.8.1",
     "zod": "4.6.5"
   },
   "devDependencies": {
+    "@intentic/testing": "0.0.0",
     "@intentic/tsconfig": "0.0.0",
+    "@types/bun": "1.4.2",
     "@types/node": "24.13.6",
     "@typescript/native-preview": "7.0.0-dev.20260707.2"
   },
   "scripts": {
     "build": "tsgo",
+    "typecheck": "tsgo --noEmit -p tsconfig.test.json",
     "watch": "tsgo --build --watch",
-    "schema": "tsgo && node scripts/write-schema.mjs"
+    "schema": "tsgo && node scripts/write-schema.mjs",
+    "test": "suites",
+    "test:watch": "suites --watch"
   }
 }

package/src/bundle.test.ts

@@ -0,0 +1,91 @@
+import { bundleProblem, bundleSpecifiers, HOST_PUBLISHED_SPECIFIERS } from "./bundle.js";
+
+// Every case is a whole bundle and the specifiers it names, in source order. The minified ones are how a bundler
+// actually emits: no whitespace a line-anchored scan could lean on.
+const CASES: readonly (readonly [string, string, readonly string[]])[] = [
+    ["a minified bundle's every import, on one line", `import{ref as e}from"vue";import{x as y}from"lodash";e(y);`, ["vue", "lodash"]],
+    ["a default import beside named ones", `import x,{y}from"z";`, ["z"]],
+    ["a namespace import", `import*as n from"z";`, ["z"]],
+    ["a default and a namespace import", `import d,*as n from"z";`, ["z"]],
+    ["a multi-line import", `import {\n    a,\n    b as c,\n} from "@intentic/sandbox";\n`, ["@intentic/sandbox"]],
+    ["a statement after a closing brace", `function f(){}import{a}from"b";`, ["b"]],
+    ["export * from", `export * from "./chunk.js";`, ["./chunk.js"]],
+    ["export * as from", `export*as ns from"ns-lib";`, ["ns-lib"]],
+    ["export {a} from", `export {a} from "a-lib";export{b as c}from'b-lib'`, ["a-lib", "b-lib"]],
+    ["export {} from", `export{}from"empty"`, ["empty"]],
+    ["a local export names nothing", `const a=1;export{a};export default a;export const b=2;`, []],
+    ["a local export, then an import after a line break", `export {a}\nimport "next"`, ["next"]],
+    ["a side-effect import", `import "polyfill";import'other';`, ["polyfill", "other"]],
+    ["a dynamic import", `const m=await import("./lazy.js");`, ["./lazy.js"]],
+    ["a dynamic import of a hole-less template", "import(`lit`).then(f)", ["lit"]],
+    ["a dynamic import with options", `import("data", { with: { type: "json" } })`, ["data"]],
+    ["a dynamic import of an expression names no module", `import(name);import("pre"+fix);import(\`t\${x}\`)`, []],
+    ["import attributes", `import cfg from "./cfg.json" with { type: "json" };`, ["./cfg.json"]],
+    ["quoted binding names", `import {"a-b" as c} from "q";export {c as "d-e"} from "r";`, ["q", "r"]],
+    ["a binding called from", `import from from "f";import {from} from "g";`, ["f", "g"]],
+    ["a specifier named twice counts once", `import a from"vue";import{b}from"vue";export*from"vue"`, ["vue"]],
+    ["the word inside a string", `const s = "import x from 'fake'";const t = 'export * from "fake"';`, []],
+    ["the word inside a template", "const s = `import x from 'fake';\nimport('fake')`;", []],
+    ["the word inside a template's hole's string", "const s = `a${\"import 'fake'\"}b`;import \"real\";", ["real"]],
+    ["an import inside a template's hole", "const s = `a${await import(\"inner\")}b`;", ["inner"]],
+    ["nested template holes", "const s=`a${`b${c}d`}e${{f:1}.f}g`;import\"after\";", ["after"]],
+    ["the word inside a line comment", `// import x from "fake"\nimport "real";`, ["real"]],
+    ["the word inside a block comment", `/* import x from "fake";\n export * from "fake2" */import "real";`, ["real"]],
+    ["a regex holding the word and a quote", `const r=/import x from "fake"/g;import "real";`, ["real"]],
+    ["a regex holding a lone quote", `if(/["']/.test(s))x();import{a}from"real";`, ["real"]],
+    ["a regex after a keyword", `function f(s){return/'/.test(s)}import"real";`, ["real"]],
+    ["a regex with a slash in a class", `const r=/[/"]/;import"real";`, ["real"]],
+    ["division is not a regex", `const a=b/2,c=d/3;import"real";`, ["real"]],
+    ["division after a call and an index", `x=f(1)/g[0]/2;import"real";`, ["real"]],
+    ["a method called import", `loader.import("fake");obj?.import("fake2");class A{import(p){}}`, []],
+    ["import.meta", `const u=import.meta.url;import "real";`, ["real"]],
+    ["an object key called import or export", `const o={import:"fake",export:"fake2"};`, []],
+    ["a private field called import", `class A{#import=1;f(){return this.#import}}`, []],
+    ["a hashbang line", `#!/usr/bin/env node\nimport "real";`, ["real"]],
+    ["escaped quotes in a string", `const s="\\"import 'fake'\\"";import "real";`, ["real"]],
+];
+
+describe("bundleSpecifiers", () => {
+    test.each(CASES)("%s", (_name, source, expected) => {
+        expect(bundleSpecifiers(source)).toEqual([...expected]);
+    });
+});
+
+describe("bundleProblem", () => {
+    test("a bundle importing only what the host publishes loads", () => {
+        const source = HOST_PUBLISHED_SPECIFIERS.map((specifier, index) => `import*as m${index} from"${specifier}";`).join("");
+        expect(bundleProblem(source)).toBe(undefined);
+    });
+
+    test("a bundle importing nothing loads", () => {
+        expect(bundleProblem(`export const activate=()=>{};`)).toBe(undefined);
+    });
+
+    test.each([
+        ["a relative static import", `import{a}from"vue";import{b}from"./chunk.js";`, "./chunk.js"],
+        ["a relative re-export", `export*from"../shared.js"`, "../shared.js"],
+        ["an absolute dynamic import", `import("/assets/lazy.js")`, "/assets/lazy.js"],
+    ])("%s is a second file", (_name, source, specifier) => {
+        expect(bundleProblem(source)).toBe(
+            `imports a second file (${specifier}): a bundle is imported from a blob URL, so nothing relative to it can resolve`,
+        );
+    });
+
+    test("every relative specifier is named, ahead of any unpublished bare one", () => {
+        expect(bundleProblem(`import"lodash";import"./a.js";export*from"./b.js"`)).toBe(
+            "imports a second file (./a.js, ./b.js): a bundle is imported from a blob URL, so nothing relative to it can resolve",
+        );
+    });
+
+    test("an unpublished bare specifier, found past the first import of a minified bundle, is named", () => {
+        expect(bundleProblem(`import{ref as e}from"vue";import{x as y}from"lodash";import("dayjs")`)).toBe(
+            "imports lodash, dayjs, which the host does not publish, bundle it in, or use one of: vue, @intentic/extension-api, @intentic/extension-ui, @tanstack/vue-query",
+        );
+    });
+
+    test("a published package's subpath is not the package", () => {
+        expect(bundleProblem(`import{h}from"vue/dist/vue.esm-bundler.js"`)).toBe(
+            "imports vue/dist/vue.esm-bundler.js, which the host does not publish, bundle it in, or use one of: vue, @intentic/extension-api, @intentic/extension-ui, @tanstack/vue-query",
+        );
+    });
+});

package/src/bundle.ts

@@ -5,15 +5,294 @@
 // What the shell's import map publishes to a bundle.
 export const HOST_PUBLISHED_SPECIFIERS = ["vue", "@intentic/extension-api", "@intentic/extension-ui", "@tanstack/vue-query"] as const;
 
-// Every specifier a single-file ESM bundle names: static imports, re-exports, bare side-effect imports, dynamic
-// import(). A regex is enough since a bundle is one file by contract.
-export const bundleSpecifiers = (source: string): string[] => [
-    ...new Set([
-        ...[...source.matchAll(/(?:^|\n)\s*(?:import|export)[^;\n]*?from\s*["'`]([^"'`]+)["'`]/gu)].map((match) => match[1] ?? ""),
-        ...[...source.matchAll(/\bimport\s*\(\s*["'`]([^"'`]+)["'`]\s*\)/gu)].map((match) => match[1] ?? ""),
-        ...[...source.matchAll(/(?:^|\n)\s*import\s*["'`]([^"'`]+)["'`]/gu)].map((match) => match[1] ?? ""),
-    ]),
-];
+// The tokens the scan tells apart. A string carries its contents, and so does a template without a `${}` hole.
+type Token =
+    | { readonly kind: "ident" | "punct"; readonly text: string }
+    | { readonly kind: "string"; readonly value: string }
+    | { readonly kind: "template"; readonly value: string | undefined }
+    | { readonly kind: "number" | "regex" };
+
+// Words after which an expression starts, so a `/` there opens a regex rather than dividing.
+const BEFORE_EXPRESSION = new Set(["return", "typeof", "instanceof", "in", "of", "new", "delete", "void", "throw", "case", "do", "else", "yield", "await", "extends"]);
+
+// Whether a `/` after `last` opens a regex. After a value it divides. A `}` counts as a statement's end, since a block
+// closes far more often than an object literal anything could divide. A misread regex is bounded by its line, see
+// regexEnd.
+const regexMayFollow = (last: Token | undefined): boolean => {
+    if (last === undefined) {
+        return true;
+    }
+    if (last.kind === "ident") {
+        return BEFORE_EXPRESSION.has(last.text);
+    }
+    return last.kind === "punct" && ![")", "]", "++", "--"].includes(last.text);
+};
+
+const IDENT = /[#$_\\\p{ID_Start}][$\\\u200C\u200D\p{ID_Continue}]*/uy;
+const NUMBER = /\.?\d[\w.]*/y;
+const LINE_BREAK = /[\n\r\u2028\u2029]/u;
+const SPACE = /\s/u;
+
+// Where a sticky `pattern` matching at `at` ends, or -1 when it does not match there.
+const matchEnd = (pattern: RegExp, source: string, at: number): number => {
+    pattern.lastIndex = at;
+    return pattern.test(source) ? pattern.lastIndex : -1;
+};
+
+const lineEnd = (source: string, at: number): number => {
+    const offset = source.slice(at).search(LINE_BREAK);
+    return offset < 0 ? source.length : at + offset;
+};
+
+interface Read {
+    readonly end: number;
+    readonly value: string;
+}
+
+// The quoted string opening at `at`: where it ends and what it holds. An unterminated one ends at its line.
+const readString = (source: string, at: number): Read => {
+    const quote = source[at];
+    for (let i = at + 1; i < source.length; i++) {
+        const char = source[i];
+        if (char === "\\") {
+            i++;
+        } else if (char === quote) {
+            return { end: i + 1, value: source.slice(at + 1, i) };
+        } else if (char === "\n" || char === "\r") {
+            return { end: i, value: source.slice(at + 1, i) };
+        }
+    }
+    return { end: source.length, value: source.slice(at + 1) };
+};
+
+// Where the regex opening at `at` ends, flags included, or -1 when its line ends first: then the slash was division.
+const regexEnd = (source: string, at: number): number => {
+    let inClass = false;
+    for (let i = at + 1; i < source.length; i++) {
+        const char = source[i] ?? "";
+        if (LINE_BREAK.test(char)) {
+            return -1;
+        }
+        if (char === "\\") {
+            i++;
+        } else if (char === "[" || char === "]") {
+            inClass = char === "[";
+        } else if (char === "/" && !inClass) {
+            return Math.max(i + 1, matchEnd(IDENT, source, i + 1));
+        }
+    }
+    return -1;
+};
+
+interface Span {
+    readonly end: number;
+    // Whether it stops at a `${` rather than at its closing backtick.
+    readonly hole: boolean;
+}
+
+// A template's text from `at` (past its backtick, or past the `}` closing a hole) to its closing backtick or its next
+// `${`.
+const templateSpan = (source: string, at: number): Span => {
+    for (let i = at; i < source.length; i++) {
+        const char = source[i];
+        if (char === "\\") {
+            i++;
+        } else if (char === "`") {
+            return { end: i + 1, hole: false };
+        } else if (char === "$" && source[i + 1] === "{") {
+            return { end: i + 2, hole: true };
+        }
+    }
+    return { end: source.length, hole: false };
+};
+
+const punctAt = (source: string, at: number): string => {
+    if (source.startsWith("...", at)) {
+        return "...";
+    }
+    const two = source.slice(at, at + 2);
+    if (two === "++" || two === "--" || (two === "?." && !/\d/u.test(source[at + 2] ?? ""))) {
+        return two;
+    }
+    return source[at] ?? "";
+};
+
+interface Lexer {
+    at: number;
+    last: Token | undefined;
+    // Code brace depth, and the depth each open template hole hands back to its template at.
+    braces: number;
+    readonly holes: number[];
+}
+
+// Past whitespace and comments from the lexer's position.
+const skipTrivia = (source: string, lexer: Lexer): void => {
+    for (;;) {
+        if (SPACE.test(source[lexer.at] ?? "")) {
+            lexer.at++;
+        } else if (source.startsWith("//", lexer.at)) {
+            lexer.at = lineEnd(source, lexer.at);
+        } else if (source.startsWith("/*", lexer.at)) {
+            const close = source.indexOf("*/", lexer.at + 2);
+            lexer.at = close < 0 ? source.length : close + 2;
+        } else {
+            return;
+        }
+    }
+};
+
+// A template's text from `from` onward: one token for a template closing here, a `${` for one opening a hole.
+const readTemplate = (source: string, lexer: Lexer, from: number, head: boolean): Token => {
+    const span = templateSpan(source, from);
+    lexer.at = span.end;
+    if (span.hole) {
+        lexer.holes.push(lexer.braces);
+        return { kind: "punct", text: "${" };
+    }
+    return { kind: "template", value: head ? source.slice(from, span.end - 1) : undefined };
+};
+
+// The token at the lexer's position, which is past any trivia and before the end.
+const readToken = (source: string, lexer: Lexer): Token => {
+    const { at } = lexer;
+    const char = source[at] ?? "";
+    const regex = char === "/" && regexMayFollow(lexer.last) ? regexEnd(source, at) : -1;
+    if (regex >= 0) {
+        lexer.at = regex;
+        return { kind: "regex" };
+    }
+    if (char === '"' || char === "'") {
+        const { end, value } = readString(source, at);
+        lexer.at = end;
+        return { kind: "string", value };
+    }
+    if (char === "`") {
+        return readTemplate(source, lexer, at + 1, true);
+    }
+    if (char === "}" && lexer.holes.at(-1) === lexer.braces) {
+        lexer.holes.pop();
+        return readTemplate(source, lexer, at + 1, false);
+    }
+    const ident = matchEnd(IDENT, source, at);
+    if (ident >= 0) {
+        lexer.at = ident;
+        return { kind: "ident", text: source.slice(at, ident) };
+    }
+    const number = matchEnd(NUMBER, source, at);
+    if (number >= 0) {
+        lexer.at = number;
+        return { kind: "number" };
+    }
+    const text = punctAt(source, at);
+    lexer.braces += text === "{" ? 1 : text === "}" ? -1 : 0;
+    lexer.at += text.length;
+    return { kind: "punct", text };
+};
+
+// Tokenizes an ES module just far enough to see its imports: string, template, comment and regex contents are skipped
+// rather than read as code, and a template's `${}` holes are read as code again.
+const tokenize = (source: string, emit: (token: Token) => void): void => {
+    const lexer: Lexer = { at: source.startsWith("#!") ? lineEnd(source, 0) : 0, last: undefined, braces: 0, holes: [] };
+    for (skipTrivia(source, lexer); lexer.at < source.length; skipTrivia(source, lexer)) {
+        lexer.last = readToken(source, lexer);
+        emit(lexer.last);
+    }
+};
+
+const isPunct = (token: Token, text: string): boolean => token.kind === "punct" && token.text === text;
+
+// Where the reading of an import or re-export stands. A clause is what sits between `import`/`export` and `from`:
+// bindings, braces, `*`, `as`, commas, quoted names; `closed` once its braces have closed, when only `from` may follow.
+type State =
+    | { readonly at: "idle" | "import" | "export" | "dynamic" | "from" }
+    | { readonly at: "argument"; readonly value: string }
+    | { readonly at: "clause"; readonly depth: number; readonly closed: boolean };
+
+const IDLE: State = { at: "idle" };
+
+// The state a clause moves to on `token`, or undefined when the token cannot sit in the clause.
+const clauseNext = (depth: number, closed: boolean, token: Token): State | undefined => {
+    if (depth === 0 && token.kind === "ident" && token.text === "from") {
+        return { at: "from" };
+    }
+    if (closed) {
+        return undefined;
+    }
+    if (isPunct(token, "{")) {
+        return { at: "clause", depth: depth + 1, closed: false };
+    }
+    if (isPunct(token, "}") && depth > 0) {
+        return { at: "clause", depth: depth - 1, closed: depth === 1 };
+    }
+    const bindingPart = token.kind === "ident" || token.kind === "string" || isPunct(token, ",") || isPunct(token, "*");
+    return bindingPart ? { at: "clause", depth, closed } : undefined;
+};
+
+// A literal module name: a string, or a template with no hole (which only `import()` accepts).
+const literalOf = (token: Token): string | undefined => (token.kind === "string" || token.kind === "template" ? token.value : undefined);
+
+// The state after `token`, recording what it completes into `found`, or undefined when the token breaks the pattern
+// under way (and must be read again from idle, since it may start the next one).
+const transition = (state: State, token: Token, found: Set<string>): State | undefined => {
+    switch (state.at) {
+        case "idle":
+            return token.kind === "ident" && (token.text === "import" || token.text === "export") ? { at: token.text } : IDLE;
+        case "import":
+            if (isPunct(token, "(")) {
+                return { at: "dynamic" };
+            }
+            if (token.kind === "string") {
+                found.add(token.value);
+                return IDLE;
+            }
+            return clauseNext(0, false, token);
+        case "export":
+            return isPunct(token, "*") || isPunct(token, "{") ? clauseNext(0, false, token) : undefined;
+        case "dynamic": {
+            const value = literalOf(token);
+            return value === undefined ? undefined : { at: "argument", value };
+        }
+        case "argument":
+            // `import("x")` or `import("x", { with: … })`; `import("x" + y)` names no one module.
+            if (isPunct(token, ")") || isPunct(token, ",")) {
+                found.add(state.value);
+            }
+            return undefined;
+        case "from":
+            if (token.kind === "string") {
+                found.add(token.value);
+                return IDLE;
+            }
+            // `import from from "x"`: the first `from` was a binding.
+            return clauseNext(0, false, token);
+        case "clause":
+            return clauseNext(state.depth, state.closed, token);
+    }
+};
+
+// Reads the specifiers off a token stream: `import … from "x"`, `import "x"`, `export … from "x"` and `import("x")`.
+const specifierReader = (found: Set<string>): ((token: Token) => void) => {
+    let state: State = IDLE;
+    let previous: Token | undefined;
+    return (token) => {
+        // `x.import(…)` is a method and `x.export` a property, never the keyword. No pattern accepts a `.`, so one
+        // before this token has already left the reader idle.
+        const member = previous !== undefined && (isPunct(previous, ".") || isPunct(previous, "?."));
+        previous = token;
+        if (!member) {
+            state = transition(state, token, found) ?? transition(IDLE, token, found) ?? IDLE;
+        }
+    };
+};
+
+// Every specifier a single-file ESM bundle names, in source order: static imports, re-exports, bare side-effect
+// imports and dynamic import() of a literal, wherever they sit (a minified bundle puts them all on one line), never
+// counting the word inside a string, a template, a comment or a regex.
+export const bundleSpecifiers = (source: string): string[] => {
+    const found = new Set<string>();
+    tokenize(source, specifierReader(found));
+    return [...found];
+};
 
 // Why this bundle cannot load, or undefined when it can, naming the offending specifiers.
 export const bundleProblem = (source: string): string | undefined => {

package/src/manifest.ts

@@ -1,11 +1,22 @@
 import { z } from "zod";
 import { MARK_FIELDS } from "./mark.js";
+import { permissionProblem } from "./permissions.js";
 import { contributesSchema } from "./points/index.js";
 
 // The extension manifest (`intentic-extension.json`, not under .claude-plugin/): the approval surface the install
 // dialog renders, and the host refuses any runtime registration whose id it didn't declare here. This file is the
 // envelope only; contributions are assembled from points/.
 
+// One "<METHOD> <path-glob>" entry, refused at parse when malformed (permissions.ts), so a bad manifest fails where it is
+// read instead of inside the route gate on its first call.
+const permissionEntry = (): z.ZodString =>
+    z.string().superRefine((entry, ctx) => {
+        const problem = permissionProblem(entry);
+        if (problem !== undefined) {
+            ctx.addIssue({ code: "custom", message: problem });
+        }
+    });
+
 const ManifestShape = z.object({
     // Declared so it survives the parse instead of being silently stripped; nothing at runtime reads it.
     $schema: z.string().optional().describe("The authoring schema, for editor completion and validation. Nothing at runtime reads it."),
@@ -54,11 +65,11 @@ const ManifestShape = z.object({
     permissions: z
         .object({
             sandbox: z
-                .array(z.string().meta({ power: { key: "sandbox:${value}", sentence: "its UI calls the sandbox route ${value}" } }))
+                .array(permissionEntry().meta({ power: { key: "sandbox:${value}", sentence: "its UI calls the sandbox route ${value}" } }))
                 .optional()
                 .describe("Daemon routes your UI half may call. Your own backend namespace needs no entry: its backend is your own code."),
             daemon: z
-                .array(z.string().meta({ power: { key: "daemon:${value}", sentence: "its backend calls the daemon route ${value}" } }))
+                .array(permissionEntry().meta({ power: { key: "daemon:${value}", sentence: "its backend calls the daemon route ${value}" } }))
                 .optional()
                 .describe(
                     "Daemon routes your SERVER half may call. Separate from `sandbox` because the two halves run as different principals: the UI as the owner's session, the backend as a minted per-extension token, so a grant to one must never quietly widen the other.",