@intentic/extension-manifest 1.176.3

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Artur Kurowski
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,74 @@
+# @intentic/extension-manifest
+
+What an extension **declares** — as opposed to what it programs against.
+
+This package holds the `intentic-extension.json` schema and the rule that matches a daemon call against the
+manifest's `permissions.sandbox` allowlist. Nothing else: no host API, no Vue, no runtime behaviour. It imports
+zod and nothing more.
+
+## Why it is its own package
+
+It exists to break a cycle. The daemon's wire contract (`@intentic/sandbox-contract`) has to validate manifests,
+because the daemon serves extension listings and gates installs — so it needs the schema. The host API
+(`@intentic/extension-api`) has to name the daemon's typed client, because that is what an extension calls the
+sandbox through — so it needs the contract. With the schema living in `extension-api`, those two requirements
+formed a loop, and the loop is why `api.sandbox` could only ever offer `request(path)` and `json<T>(path)`: a
+string-shaped door to a fully typed surface, with every extension re-writing the URL, the method and the
+response shape by hand.
+
+Splitting the declaration vocabulary out settles it in one direction:
+
+```
+extension-manifest  ←  sandbox-contract  ←  extension-api
+```
+
+Both of the other packages depend on this one; this one depends on neither. `extension-api` may now name
+contract types, which is what lets `api.sandbox.rpc` be typed.
+
+## One point, one file
+
+What a manifest may declare is not one schema — it is thirteen independent ones, and they used to share a file
+every feature had to edit to add anything, in two places at once. Each now lives alone under
+[src/points/](src/points), as its key, its shape and **the sentence that explains it to the author**, and
+`contributes` is assembled from the set. Adding a contribution point is a file plus a line.
+
+Binding the description to the schema is the part that pays. It used to sit in a `//` comment — read by
+maintainers, never by the one person it was written for — so a manifest was written by copying another
+extension's and guessing. Worse, zod *strips* what it does not declare rather than refusing it, at every level:
+a misspelt `viewers` was not an error, it was a viewer that never appeared, found at install, with the manifest
+parsing perfectly. The descriptions now generate out to `intentic-extension.schema.json`, which an editor reads
+to give completion, hover documentation and a red squiggle on a key nothing declares.
+
+That schema is **strict where the runtime is lenient**, deliberately. Authoring is where an unknown key is a
+typo worth shouting about; runtime is where one is a manifest written for a newer host, which an older daemon
+must go on installing with the point it does not understand ignored — otherwise every addition to that list
+would be a breaking change.
+
+## Key files
+
+- [src/points/](src/points) — one contribution point per file, and the index that collects them into
+  `CONTRIBUTION_POINTS` and assembles `contributes` from it.
+- [src/contribution-point.ts](src/contribution-point.ts) — what a point *is*: name, description, schema. The
+  reasoning for why the description travels with the schema rather than sitting in a comment.
+- [src/manifest.ts](src/manifest.ts) — the envelope: who the extension is, which host it needs, what code it
+  ships, how far it may reach. The manifest is the **approval + gating surface**: the install dialog shows
+  exactly the declared contribution points, and the host refuses any runtime registration the approved manifest
+  never declared.
+- [src/json-schema.ts](src/json-schema.ts) — the authoring schema, emitted from those points.
+- [src/permissions.ts](src/permissions.ts) — `sandboxRouteAllowed`, the `"<METHOD> <path-glob>"` matcher behind
+  `permissions.sandbox`. Kept beside the schema because it is the rule for one of the schema's own fields.
+
+## Conventions & gotchas
+
+- **Declaration only.** If something here needed to know how the host behaves, it would belong in
+  `extension-api` instead. The test is whether the daemon — which has no host and no browser — still needs it.
+- The contribution-point list is read back by the host's surface guard, which compares it against
+  `extension-api`'s recorded surface and its README — so adding a contribution point here without bumping the
+  SDK version there fails that test rather than shipping a version number that lies about what it supports.
+- **The generated schema is committed, in two copies** — the one shipped in this package and the one the site
+  serves at the `$schema` URL. Run `pnpm --filter @intentic/extension-manifest schema` after touching a point
+  and commit both; `manifest-schema.test.ts` regenerates and compares, the way `contract.lock.json` is guarded.
+  A generated document only guards anything if a diff shows it moving.
+- Points are collected in an explicit list rather than by a module-load side effect. Two committed documents
+  are generated from them — that schema and the wire contract's lock — and a registry that filled itself as
+  modules happened to load would make both depend on import order.

package/dist/bundle.d.ts

@@ -0,0 +1,4 @@
+export declare const HOST_PUBLISHED_SPECIFIERS: readonly ["vue", "@intentic/extension-api", "@intentic/extension-ui", "@tanstack/vue-query"];
+export declare const bundleSpecifiers: (source: string) => string[];
+export declare const bundleProblem: (source: string) => string | undefined;
+//# sourceMappingURL=bundle.d.ts.map

package/dist/bundle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bundle.d.ts","sourceRoot":"","sources":["../src/bundle.ts"],"names":[],"mappings":"AAaA,eAAO,MAAM,yBAAyB,YAAI,KAAK,EAAE,yBAAyB,EAAE,wBAAwB,EAAE,qBAAqB,CAAU,CAAC;AAKtI,eAAO,MAAM,gBAAgB,WAAY,MAAM,KAAG,MAAM,EAMvD,CAAC;AAIF,eAAO,MAAM,aAAa,WAAY,MAAM,KAAG,MAAM,GAAG,SAYvD,CAAC"}

package/dist/bundle.js

@@ -0,0 +1,22 @@
+export const HOST_PUBLISHED_SPECIFIERS = ["vue", "@intentic/extension-api", "@intentic/extension-ui", "@tanstack/vue-query"];
+export const bundleSpecifiers = (source) => [
+    ...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] ?? ""),
+    ]),
+];
+export const bundleProblem = (source) => {
+    const specifiers = bundleSpecifiers(source);
+    const relative = specifiers.filter((specifier) => specifier.startsWith(".") || specifier.startsWith("/"));
+    if (relative.length > 0) {
+        return `imports a second file (${relative.join(", ")}) — a bundle is imported from a blob URL, so nothing relative to it can resolve`;
+    }
+    const published = new Set(HOST_PUBLISHED_SPECIFIERS);
+    const unpublished = specifiers.filter((specifier) => !published.has(specifier));
+    if (unpublished.length > 0) {
+        return `imports ${unpublished.join(", ")}, which the host does not publish — bundle it in, or use one of: ${HOST_PUBLISHED_SPECIFIERS.join(", ")}`;
+    }
+    return undefined;
+};
+//# sourceMappingURL=bundle.js.map

package/dist/bundle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bundle.js","sourceRoot":"","sources":["../src/bundle.ts"],"names":[],"mappings":"AAaA,MAAM,CAAC,MAAM,yBAAyB,GAAG,CAAC,KAAK,EAAE,yBAAyB,EAAE,wBAAwB,EAAE,qBAAqB,CAAU,CAAC;AAKtI,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAAC,MAAc,EAAY,EAAE,CAAC;IAC1D,GAAG,IAAI,GAAG,CAAC;QACP,GAAG,CAAC,GAAG,MAAM,CAAC,QAAQ,CAAC,kEAAkE,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;QAC1H,GAAG,CAAC,GAAG,MAAM,CAAC,QAAQ,CAAC,4CAA4C,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;QACpG,GAAG,CAAC,GAAG,MAAM,CAAC,QAAQ,CAAC,2CAA2C,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;KACtG,CAAC;CACL,CAAC;AAIF,MAAM,CAAC,MAAM,aAAa,GAAG,CAAC,MAAc,EAAsB,EAAE;IAChE,MAAM,UAAU,GAAG,gBAAgB,CAAC,MAAM,CAAC,CAAC;IAC5C,MAAM,QAAQ,GAAG,UAAU,CAAC,MAAM,CAAC,CAAC,SAAS,EAAE,EAAE,CAAC,SAAS,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,SAAS,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC;IAC1G,IAAI,QAAQ,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACtB,OAAO,0BAA0B,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,iFAAiF,CAAC;IAC1I,CAAC;IACD,MAAM,SAAS,GAAG,IAAI,GAAG,CAAS,yBAAyB,CAAC,CAAC;IAC7D,MAAM,WAAW,GAAG,UAAU,CAAC,MAAM,CAAC,CAAC,SAAS,EAAE,EAAE,CAAC,CAAC,SAAS,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC;IAChF,IAAI,WAAW,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACzB,OAAO,WAAW,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,oEAAoE,yBAAyB,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;IACvJ,CAAC;IACD,OAAO,SAAS,CAAC;AACrB,CAAC,CAAC"}

package/dist/contribution-point.d.ts

@@ -0,0 +1,7 @@
+import type { z } from "zod";
+export interface ContributionPoint<Name extends string = string, Schema extends z.ZodType = z.ZodType> {
+    readonly name: Name;
+    readonly description: string;
+    readonly schema: Schema;
+}
+//# sourceMappingURL=contribution-point.d.ts.map

package/dist/contribution-point.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contribution-point.d.ts","sourceRoot":"","sources":["../src/contribution-point.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAe7B,MAAM,WAAW,iBAAiB,CAAC,IAAI,SAAS,MAAM,GAAG,MAAM,EAAE,MAAM,SAAS,CAAC,CAAC,OAAO,GAAG,CAAC,CAAC,OAAO;IAEjG,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC;IAIpB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAG7B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CAC3B"}

package/dist/contribution-point.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=contribution-point.js.map

package/dist/contribution-point.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"contribution-point.js","sourceRoot":"","sources":["../src/contribution-point.ts"],"names":[],"mappings":""}

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./bundle.js";
+export * from "./contribution-point.js";
+export * from "./json-schema.js";
+export * from "./manifest.js";
+export * from "./permissions.js";
+export * from "./points/index.js";
+export * from "./powers-diff.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,yBAAyB,CAAC;AACxC,cAAc,kBAAkB,CAAC;AACjC,cAAc,eAAe,CAAC;AAC9B,cAAc,kBAAkB,CAAC;AACjC,cAAc,mBAAmB,CAAC;AAClC,cAAc,kBAAkB,CAAC"}

package/dist/index.js

@@ -0,0 +1,8 @@
+export * from "./bundle.js";
+export * from "./contribution-point.js";
+export * from "./json-schema.js";
+export * from "./manifest.js";
+export * from "./permissions.js";
+export * from "./points/index.js";
+export * from "./powers-diff.js";
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,yBAAyB,CAAC;AACxC,cAAc,kBAAkB,CAAC;AACjC,cAAc,eAAe,CAAC;AAC9B,cAAc,kBAAkB,CAAC;AACjC,cAAc,mBAAmB,CAAC;AAClC,cAAc,kBAAkB,CAAC"}

package/dist/json-schema.d.ts

@@ -0,0 +1,4 @@
+export declare const MANIFEST_SCHEMA_URL = "https://intentic.dev/intentic-extension.schema.json";
+export declare const manifestJsonSchema: () => Record<string, unknown>;
+export declare const serializeManifestJsonSchema: (schema: Record<string, unknown>) => string;
+//# sourceMappingURL=json-schema.d.ts.map

package/dist/json-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json-schema.d.ts","sourceRoot":"","sources":["../src/json-schema.ts"],"names":[],"mappings":"AAqBA,eAAO,MAAM,mBAAmB,wDAAwD,CAAC;AA2BzF,eAAO,MAAM,kBAAkB,QAAO,MAAM,CAAC,MAAM,EAAE,OAAO,CAS3D,CAAC;AAIF,eAAO,MAAM,2BAA2B,WAAY,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAG,MAAqD,CAAC"}

package/dist/json-schema.js

@@ -0,0 +1,33 @@
+import { z } from "zod";
+import { ExtensionManifestSchema } from "./manifest.js";
+export const MANIFEST_SCHEMA_URL = "https://intentic.dev/intentic-extension.schema.json";
+const closeToUnknownKeys = (node) => {
+    if (Array.isArray(node)) {
+        for (const item of node) {
+            closeToUnknownKeys(item);
+        }
+        return;
+    }
+    if (typeof node !== "object" || node === null) {
+        return;
+    }
+    const schema = node;
+    if (schema["type"] === "object" && schema["properties"] !== undefined && schema["additionalProperties"] === undefined) {
+        schema["additionalProperties"] = false;
+    }
+    for (const value of Object.values(schema)) {
+        closeToUnknownKeys(value);
+    }
+};
+export const manifestJsonSchema = () => {
+    const schema = z.toJSONSchema(ExtensionManifestSchema, { unrepresentable: "any", io: "input" });
+    closeToUnknownKeys(schema);
+    return {
+        ...schema,
+        $id: MANIFEST_SCHEMA_URL,
+        title: "intentic extension manifest",
+        description: "What an intentic extension declares: who it is, which host it needs, what code it ships, and what it contributes.",
+    };
+};
+export const serializeManifestJsonSchema = (schema) => `${JSON.stringify(schema, undefined, 4)}\n`;
+//# sourceMappingURL=json-schema.js.map

package/dist/json-schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"json-schema.js","sourceRoot":"","sources":["../src/json-schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,uBAAuB,EAAE,MAAM,eAAe,CAAC;AAoBxD,MAAM,CAAC,MAAM,mBAAmB,GAAG,qDAAqD,CAAC;AAMzF,MAAM,kBAAkB,GAAG,CAAC,IAAa,EAAQ,EAAE;IAC/C,IAAI,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC;QACtB,KAAK,MAAM,IAAI,IAAI,IAAI,EAAE,CAAC;YACtB,kBAAkB,CAAC,IAAI,CAAC,CAAC;QAC7B,CAAC;QACD,OAAO;IACX,CAAC;IACD,IAAI,OAAO,IAAI,KAAK,QAAQ,IAAI,IAAI,KAAK,IAAI,EAAE,CAAC;QAC5C,OAAO;IACX,CAAC;IACD,MAAM,MAAM,GAAG,IAA+B,CAAC;IAC/C,IAAI,MAAM,CAAC,MAAM,CAAC,KAAK,QAAQ,IAAI,MAAM,CAAC,YAAY,CAAC,KAAK,SAAS,IAAI,MAAM,CAAC,sBAAsB,CAAC,KAAK,SAAS,EAAE,CAAC;QACpH,MAAM,CAAC,sBAAsB,CAAC,GAAG,KAAK,CAAC;IAC3C,CAAC;IACD,KAAK,MAAM,KAAK,IAAI,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC;QACxC,kBAAkB,CAAC,KAAK,CAAC,CAAC;IAC9B,CAAC;AACL,CAAC,CAAC;AAIF,MAAM,CAAC,MAAM,kBAAkB,GAAG,GAA4B,EAAE;IAC5D,MAAM,MAAM,GAAG,CAAC,CAAC,YAAY,CAAC,uBAAuB,EAAE,EAAE,eAAe,EAAE,KAAK,EAAE,EAAE,EAAE,OAAO,EAAE,CAA4B,CAAC;IAC3H,kBAAkB,CAAC,MAAM,CAAC,CAAC;IAC3B,OAAO;QACH,GAAG,MAAM;QACT,GAAG,EAAE,mBAAmB;QACxB,KAAK,EAAE,6BAA6B;QACpC,WAAW,EAAE,mHAAmH;KACnI,CAAC;AACN,CAAC,CAAC;AAIF,MAAM,CAAC,MAAM,2BAA2B,GAAG,CAAC,MAA+B,EAAU,EAAE,CAAC,GAAG,IAAI,CAAC,SAAS,CAAC,MAAM,EAAE,SAAS,EAAE,CAAC,CAAC,IAAI,CAAC"}

package/dist/manifest.d.ts

@@ -0,0 +1,300 @@
+import { z } from "zod";
+export declare const ExtensionManifestSchema: z.ZodObject<{
+    logo: z.ZodOptional<z.ZodString>;
+    icon: z.ZodOptional<z.ZodString>;
+    $schema: z.ZodOptional<z.ZodString>;
+    publisher: z.ZodString;
+    name: z.ZodString;
+    version: z.ZodString;
+    category: z.ZodOptional<z.ZodString>;
+    engines: z.ZodObject<{
+        intentic: z.ZodString;
+    }, z.core.$strip>;
+    entry: z.ZodOptional<z.ZodString>;
+    server: z.ZodOptional<z.ZodString>;
+    permissions: z.ZodOptional<z.ZodObject<{
+        sandbox: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        daemon: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+    contributes: z.ZodOptional<z.ZodObject<{
+        agent: z.ZodOptional<z.ZodObject<{
+            path: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        automationTemplates: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            title: z.ZodString;
+            logo: z.ZodOptional<z.ZodString>;
+            icon: z.ZodOptional<z.ZodString>;
+            requires: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            trigger: z.ZodObject<{
+                kind: z.ZodEnum<{
+                    event: "event";
+                    listener: "listener";
+                    schedule: "schedule";
+                    workspace: "workspace";
+                }>;
+                cron: z.ZodOptional<z.ZodString>;
+                provider: z.ZodOptional<z.ZodString>;
+                eventType: z.ZodOptional<z.ZodString>;
+                event: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>;
+            guard: z.ZodOptional<z.ZodString>;
+            holdForSeconds: z.ZodOptional<z.ZodNumber>;
+            prompt: z.ZodString;
+            note: z.ZodOptional<z.ZodString>;
+            setup: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+            offer: z.ZodOptional<z.ZodEnum<{
+                configure: "configure";
+                create: "create";
+            }>>;
+            chore: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>>;
+        bin: z.ZodOptional<z.ZodString>;
+        capabilities: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            id: z.ZodString;
+            catalog: z.ZodObject<{
+                logo: z.ZodOptional<z.ZodString>;
+                icon: z.ZodOptional<z.ZodString>;
+                name: z.ZodString;
+                description: z.ZodString;
+                category: z.ZodString;
+                hint: z.ZodOptional<z.ZodString>;
+                guide: z.ZodOptional<z.ZodObject<{
+                    url: z.ZodOptional<z.ZodString>;
+                    urlFromField: z.ZodOptional<z.ZodString>;
+                    path: z.ZodOptional<z.ZodString>;
+                    linkLabel: z.ZodOptional<z.ZodString>;
+                    scopes: z.ZodOptional<z.ZodString>;
+                    steps: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>;
+            kind: z.ZodLiteral<"cli">;
+            fields: z.ZodArray<z.ZodObject<{
+                key: z.ZodString;
+                label: z.ZodString;
+                placeholder: z.ZodOptional<z.ZodString>;
+                secret: z.ZodOptional<z.ZodBoolean>;
+                optional: z.ZodOptional<z.ZodBoolean>;
+                multiline: z.ZodOptional<z.ZodBoolean>;
+                boolean: z.ZodOptional<z.ZodBoolean>;
+                hint: z.ZodOptional<z.ZodString>;
+                rebuild: z.ZodOptional<z.ZodBoolean>;
+                default: z.ZodOptional<z.ZodString>;
+                options: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    value: z.ZodString;
+                    label: z.ZodString;
+                }, z.core.$strip>>>;
+                when: z.ZodOptional<z.ZodString>;
+                value: z.ZodOptional<z.ZodString>;
+                totp: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>>;
+            env: z.ZodRecord<z.ZodString, z.ZodString>;
+            skill: z.ZodString;
+            fragment: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            id: z.ZodString;
+            catalog: z.ZodObject<{
+                logo: z.ZodOptional<z.ZodString>;
+                icon: z.ZodOptional<z.ZodString>;
+                name: z.ZodString;
+                description: z.ZodString;
+                category: z.ZodString;
+                hint: z.ZodOptional<z.ZodString>;
+                guide: z.ZodOptional<z.ZodObject<{
+                    url: z.ZodOptional<z.ZodString>;
+                    urlFromField: z.ZodOptional<z.ZodString>;
+                    path: z.ZodOptional<z.ZodString>;
+                    linkLabel: z.ZodOptional<z.ZodString>;
+                    scopes: z.ZodOptional<z.ZodString>;
+                    steps: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>;
+            fields: z.ZodArray<z.ZodObject<{
+                key: z.ZodString;
+                label: z.ZodString;
+                placeholder: z.ZodOptional<z.ZodString>;
+                secret: z.ZodOptional<z.ZodBoolean>;
+                optional: z.ZodOptional<z.ZodBoolean>;
+                multiline: z.ZodOptional<z.ZodBoolean>;
+                boolean: z.ZodOptional<z.ZodBoolean>;
+                hint: z.ZodOptional<z.ZodString>;
+                rebuild: z.ZodOptional<z.ZodBoolean>;
+                default: z.ZodOptional<z.ZodString>;
+                options: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    value: z.ZodString;
+                    label: z.ZodString;
+                }, z.core.$strip>>>;
+                when: z.ZodOptional<z.ZodString>;
+                value: z.ZodOptional<z.ZodString>;
+                totp: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>>;
+            kind: z.ZodLiteral<"browser">;
+            loginUrl: z.ZodOptional<z.ZodURL>;
+            homeUrl: z.ZodOptional<z.ZodURL>;
+            skill: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            id: z.ZodString;
+            catalog: z.ZodObject<{
+                logo: z.ZodOptional<z.ZodString>;
+                icon: z.ZodOptional<z.ZodString>;
+                name: z.ZodString;
+                description: z.ZodString;
+                category: z.ZodString;
+                hint: z.ZodOptional<z.ZodString>;
+                guide: z.ZodOptional<z.ZodObject<{
+                    url: z.ZodOptional<z.ZodString>;
+                    urlFromField: z.ZodOptional<z.ZodString>;
+                    path: z.ZodOptional<z.ZodString>;
+                    linkLabel: z.ZodOptional<z.ZodString>;
+                    scopes: z.ZodOptional<z.ZodString>;
+                    steps: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>;
+            fields: z.ZodArray<z.ZodObject<{
+                key: z.ZodString;
+                label: z.ZodString;
+                placeholder: z.ZodOptional<z.ZodString>;
+                secret: z.ZodOptional<z.ZodBoolean>;
+                optional: z.ZodOptional<z.ZodBoolean>;
+                multiline: z.ZodOptional<z.ZodBoolean>;
+                boolean: z.ZodOptional<z.ZodBoolean>;
+                hint: z.ZodOptional<z.ZodString>;
+                rebuild: z.ZodOptional<z.ZodBoolean>;
+                default: z.ZodOptional<z.ZodString>;
+                options: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    value: z.ZodString;
+                    label: z.ZodString;
+                }, z.core.$strip>>>;
+                when: z.ZodOptional<z.ZodString>;
+                value: z.ZodOptional<z.ZodString>;
+                totp: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>>;
+            kind: z.ZodLiteral<"host">;
+            skill: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            id: z.ZodString;
+            catalog: z.ZodObject<{
+                logo: z.ZodOptional<z.ZodString>;
+                icon: z.ZodOptional<z.ZodString>;
+                name: z.ZodString;
+                description: z.ZodString;
+                category: z.ZodString;
+                hint: z.ZodOptional<z.ZodString>;
+                guide: z.ZodOptional<z.ZodObject<{
+                    url: z.ZodOptional<z.ZodString>;
+                    urlFromField: z.ZodOptional<z.ZodString>;
+                    path: z.ZodOptional<z.ZodString>;
+                    linkLabel: z.ZodOptional<z.ZodString>;
+                    scopes: z.ZodOptional<z.ZodString>;
+                    steps: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>;
+            fields: z.ZodArray<z.ZodObject<{
+                key: z.ZodString;
+                label: z.ZodString;
+                placeholder: z.ZodOptional<z.ZodString>;
+                secret: z.ZodOptional<z.ZodBoolean>;
+                optional: z.ZodOptional<z.ZodBoolean>;
+                multiline: z.ZodOptional<z.ZodBoolean>;
+                boolean: z.ZodOptional<z.ZodBoolean>;
+                hint: z.ZodOptional<z.ZodString>;
+                rebuild: z.ZodOptional<z.ZodBoolean>;
+                default: z.ZodOptional<z.ZodString>;
+                options: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    value: z.ZodString;
+                    label: z.ZodString;
+                }, z.core.$strip>>>;
+                when: z.ZodOptional<z.ZodString>;
+                value: z.ZodOptional<z.ZodString>;
+                totp: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>>;
+            kind: z.ZodLiteral<"agent">;
+        }, z.core.$strip>], "kind">>>;
+        commands: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            command: z.ZodString;
+            title: z.ZodString;
+            icon: z.ZodOptional<z.ZodString>;
+            keybinding: z.ZodOptional<z.ZodString>;
+            when: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        documents: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodString;
+        }, z.core.$strip>>>;
+        environment: z.ZodOptional<z.ZodObject<{
+            fragment: z.ZodString;
+        }, z.core.$strip>>;
+        files: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            invalidates: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>>>;
+        listener: z.ZodOptional<z.ZodObject<{
+            provider: z.ZodString;
+            events: z.ZodArray<z.ZodObject<{
+                type: z.ZodString;
+                label: z.ZodString;
+            }, z.core.$strip>>;
+            automation: z.ZodObject<{
+                label: z.ZodString;
+                mentionLabel: z.ZodOptional<z.ZodString>;
+                channel: z.ZodObject<{
+                    label: z.ZodString;
+                    placeholder: z.ZodString;
+                    hint: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>;
+                branchField: z.ZodOptional<z.ZodObject<{
+                    label: z.ZodString;
+                    placeholder: z.ZodString;
+                    hint: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
+                starterPrompt: z.ZodString;
+            }, z.core.$strip>;
+        }, z.core.$strip>>;
+        processes: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            command: z.ZodString;
+            cwd: z.ZodOptional<z.ZodString>;
+            port: z.ZodOptional<z.ZodLiteral<"auto">>;
+            preview: z.ZodOptional<z.ZodBoolean>;
+            autoStart: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>>;
+        settings: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            type: z.ZodEnum<{
+                boolean: "boolean";
+                enum: "enum";
+                number: "number";
+                string: "string";
+            }>;
+            title: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            default: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+            enum: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            secret: z.ZodOptional<z.ZodBoolean>;
+            env: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        viewers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            extensions: z.ZodArray<z.ZodString>;
+            fetch: z.ZodEnum<{
+                blob: "blob";
+                text: "text";
+                url: "url";
+            }>;
+        }, z.core.$strip>>>;
+        views: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodString;
+            surface: z.ZodEnum<{
+                directory: "directory";
+                rail: "rail";
+                sandbox: "sandbox";
+            }>;
+            badge: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type ExtensionManifest = z.infer<typeof ExtensionManifestSchema>;
+export declare const extensionIdOf: (manifest: Pick<ExtensionManifest, "publisher" | "name">) => string;
+//# sourceMappingURL=manifest.d.ts.map

package/dist/manifest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manifest.d.ts","sourceRoot":"","sources":["../src/manifest.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAaxB,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAqFlC,CAAC;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAIxE,eAAO,MAAM,aAAa,aAAc,IAAI,CAAC,iBAAiB,EAAE,WAAW,GAAG,MAAM,CAAC,KAAG,MAAkD,CAAC"}

package/dist/manifest.js

@@ -0,0 +1,46 @@
+import { z } from "zod";
+import { MARK_FIELDS } from "./mark.js";
+import { contributesSchema } from "./points/index.js";
+export const ExtensionManifestSchema = z.object({
+    $schema: z.string().optional().describe("The authoring schema, for editor completion and validation. Nothing at runtime reads it."),
+    publisher: z.string().regex(/^[a-z0-9][a-z0-9-]*$/),
+    name: z.string().regex(/^[a-z0-9][a-z0-9-]*$/),
+    version: z.string().min(1).describe("Your own semver — display and identity only. The installed code's identity is the pinned commit sha."),
+    category: z
+        .string()
+        .min(1)
+        .optional()
+        .describe("Which section of the Extensions tab this sits under — a grouping by what it is FOR, which cannot be derived from what it contributes. A section this app has never heard of lands in “Other” rather than failing to install."),
+    ...MARK_FIELDS,
+    engines: z
+        .object({ intentic: z.string().min(1) })
+        .describe("A semver range over the host's extension API version, checked before your code is activated."),
+    entry: z
+        .string()
+        .min(1)
+        .refine((value) => !value.split("/").includes(".."), { message: "entry must stay inside the checkout" })
+        .optional()
+        .describe("Repo-relative path of your prebuilt single-file ESM bundle, built with `vue` and `@intentic/extension-api` as externals. Absent ⇒ an extension with no UI."),
+    server: z
+        .string()
+        .min(1)
+        .refine((value) => !value.split("/").includes(".."), { message: "server must stay inside the checkout" })
+        .optional()
+        .describe("Repo-relative path of your prebuilt single-file node ESM server bundle, exporting `activateServer`. Served under your own route namespace, which the daemon proxies. Nothing is provided at runtime but node builtins, so bundle everything else in. Absent ⇒ no backend."),
+    permissions: z
+        .object({
+        sandbox: z
+            .array(z.string())
+            .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())
+            .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."),
+    })
+        .optional()
+        .describe('How far this extension may reach into the daemon, as "<METHOD> <path-glob>" entries where `*` matches one path segment — e.g. "GET /panels", "POST /panels/*/start". The install dialog shows these, the host refuses anything undeclared, and the usage ledger records which were actually earned.'),
+    contributes: contributesSchema.optional(),
+});
+export const extensionIdOf = (manifest) => `${manifest.publisher}.${manifest.name}`;
+//# sourceMappingURL=manifest.js.map

package/dist/manifest.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"manifest.js","sourceRoot":"","sources":["../src/manifest.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AACxC,OAAO,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAWtD,MAAM,CAAC,MAAM,uBAAuB,GAAG,CAAC,CAAC,MAAM,CAAC;IAK5C,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,0FAA0F,CAAC;IACnI,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,KAAK,CAAC,sBAAsB,CAAC;IACnD,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,KAAK,CAAC,sBAAsB,CAAC;IAE9C,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,sGAAsG,CAAC;IAO3I,QAAQ,EAAE,CAAC;SACN,MAAM,EAAE;SACR,GAAG,CAAC,CAAC,CAAC;SACN,QAAQ,EAAE;SACV,QAAQ,CACL,8NAA8N,CACjO;IAML,GAAG,WAAW;IAEd,OAAO,EAAE,CAAC;SACL,MAAM,CAAC,EAAE,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC;SACvC,QAAQ,CAAC,8FAA8F,CAAC;IAG7G,KAAK,EAAE,CAAC;SACH,MAAM,EAAE;SACR,GAAG,CAAC,CAAC,CAAC;SACN,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,EAAE,OAAO,EAAE,qCAAqC,EAAE,CAAC;SACvG,QAAQ,EAAE;SACV,QAAQ,CACL,4JAA4J,CAC/J;IAOL,MAAM,EAAE,CAAC;SACJ,MAAM,EAAE;SACR,GAAG,CAAC,CAAC,CAAC;SACN,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,EAAE,OAAO,EAAE,sCAAsC,EAAE,CAAC;SACxG,QAAQ,EAAE;SACV,QAAQ,CACL,2QAA2Q,CAC9Q;IAWL,WAAW,EAAE,CAAC;SACT,MAAM,CAAC;QACJ,OAAO,EAAE,CAAC;aACL,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC;aACjB,QAAQ,EAAE;aACV,QAAQ,CAAC,gHAAgH,CAAC;QAC/H,MAAM,EAAE,CAAC;aACJ,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC;aACjB,QAAQ,EAAE;aACV,QAAQ,CACL,0PAA0P,CAC7P;KACR,CAAC;SACD,QAAQ,EAAE;SACV,QAAQ,CACL,qSAAqS,CACxS;IACL,WAAW,EAAE,iBAAiB,CAAC,QAAQ,EAAE;CAC5C,CAAC,CAAC;AAKH,MAAM,CAAC,MAAM,aAAa,GAAG,CAAC,QAAuD,EAAU,EAAE,CAAC,GAAG,QAAQ,CAAC,SAAS,IAAI,QAAQ,CAAC,IAAI,EAAE,CAAC"}

package/dist/mark.d.ts

@@ -0,0 +1,6 @@
+import { z } from "zod";
+export declare const MARK_FIELDS: {
+    logo: z.ZodOptional<z.ZodString>;
+    icon: z.ZodOptional<z.ZodString>;
+};
+//# sourceMappingURL=mark.d.ts.map

package/dist/mark.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mark.d.ts","sourceRoot":"","sources":["../src/mark.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAiBxB,eAAO,MAAM,WAAW;IAGpB,IAAI;IAOJ,IAAI;CAMP,CAAC"}

package/dist/mark.js

@@ -0,0 +1,12 @@
+import { z } from "zod";
+export const MARK_FIELDS = {
+    logo: z
+        .string()
+        .optional()
+        .describe('A simple-icons slug, fetched from a CDN — right for standing in for somebody else\'s product. Add a "/<hex>" suffix to force a colour for a mark that vanishes against the surface it lands on. Unreachable in an offline sandbox, so it falls back to `icon`, then to initials.'),
+    icon: z
+        .string()
+        .optional()
+        .describe("A name from the host's own icon set, drawn when no simple-icons slug fits. It ships in the image, follows the theme and costs no request — what actually carries a first-party extension. An unknown name falls back to initials rather than to a hole."),
+};
+//# sourceMappingURL=mark.js.map

package/dist/mark.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mark.js","sourceRoot":"","sources":["../src/mark.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAiBxB,MAAM,CAAC,MAAM,WAAW,GAAG;IAGvB,IAAI,EAAE,CAAC;SACF,MAAM,EAAE;SACR,QAAQ,EAAE;SACV,QAAQ,CACL,kRAAkR,CACrR;IAEL,IAAI,EAAE,CAAC;SACF,MAAM,EAAE;SACR,QAAQ,EAAE;SACV,QAAQ,CACL,yPAAyP,CAC5P;CACR,CAAC"}

package/dist/permissions.d.ts

@@ -0,0 +1,2 @@
+export declare const sandboxRouteAllowed: (permissions: readonly string[], method: string, path: string) => boolean;
+//# sourceMappingURL=permissions.d.ts.map

package/dist/permissions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"permissions.d.ts","sourceRoot":"","sources":["../src/permissions.ts"],"names":[],"mappings":"AA4BA,eAAO,MAAM,mBAAmB,gBAAiB,SAAS,MAAM,EAAE,UAAU,MAAM,QAAQ,MAAM,KAAG,OAOlG,CAAC"}