every-plugin 2.10.1 → 3.0.0-rc.0

package/dist/ui/manifest/manifest-schema.cjs

@@ -0,0 +1,97 @@
+const require_mount_registry = require('./mount-registry.cjs');
+let zod = require("zod");
+
+//#region src/ui/manifest/manifest-schema.ts
+/**
+* manifest.gen.json — pure data emitted by the generator from route files
+* only (ADR 0008 §2). Nothing here is hand-maintained; this schema is the
+* composition contract and the audit/marketplace surface. The host refuses
+* unknown `manifestVersion` majors.
+*/
+/**
+* The manifest contract major this code speaks. Emitted by the generator and
+* enforced at every load (the host parses through `parsePluginManifest`; the
+* client parse of the compose payload checks it — a skewed major degrades to
+* the core-only tree instead of silently mis-constructing).
+*/
+const MANIFEST_VERSION = 2;
+const SUPPORTED_MANIFEST_VERSION = 2;
+const RouteRecordSchema = zod.z.object({
+	/** Full route id, root-relative, no leading slash. e.g. "_public/login" */
+	id: zod.z.string(),
+	/** Node kind — the @tanstack/virtual-file-routes vocabulary. */
+	type: zod.z.enum([
+		"route",
+		"layout",
+		"index"
+	]),
+	/** URL path relative to the parent; absent for pathless layouts. */
+	path: zod.z.string().optional(),
+	/** id of the parent record within the same plugin; absent = mount-level. */
+	parentId: zod.z.string().optional(),
+	/** Set on ROOT-level pathless layouts: the mount this subtree declares. */
+	mount: zod.z.enum(require_mount_registry.MOUNTS).optional(),
+	/** Route file relative to the routes directory (options source). */
+	file: zod.z.string().optional()
+});
+const PluginManifestSchema = zod.z.object({
+	/** Plugin key — derived from the workspace/config key by the emitter. */
+	name: zod.z.string(),
+	/** Contract version — enforced by `parsePluginManifest` / the payload check. */
+	manifestVersion: zod.z.number().int(),
+	/** Lifted from the plugin's `__root` route options, if any. */
+	rootMeta: zod.z.object({
+		hasHead: zod.z.boolean().optional(),
+		hasStaticData: zod.z.boolean().optional()
+	}).optional(),
+	routes: zod.z.array(RouteRecordSchema)
+});
+/**
+* The load-time contract check — one diagnostic for a manifest from a
+* different framework major. Every manifest load goes through this.
+*/
+function parsePluginManifest(data) {
+	const parsed = PluginManifestSchema.parse(data);
+	if (parsed.manifestVersion !== 2) throw new Error(manifestVersionIssue(parsed.name, parsed.manifestVersion));
+	return parsed;
+}
+const manifestVersionIssue = (name, found) => `unsupported manifest version ${found} in "${name}" — this build speaks ${2}; regenerate manifest.gen.json with the installed framework`;
+const ManifestSchema = zod.z.object({
+	manifestVersion: zod.z.number().int(),
+	plugins: zod.z.array(PluginManifestSchema)
+});
+/**
+* The client compose payload — the runtime-config `ui.compose` block the
+* server embeds and the client reconstructs the tree from. Single home:
+* everything-dev's client-config schema, the hydrate client, and the host's
+* ui-compose all derive from this schema.
+*/
+const ComposeRemoteSchema = zod.z.object({
+	key: zod.z.string(),
+	name: zod.z.string(),
+	entry: zod.z.string(),
+	/** the remote's (hashed) browser-manifest URL — preferred over deriving
+	* one from `entry` by stripping the legacy fixed entry name */
+	manifestUrl: zod.z.string().optional()
+});
+const ComposePayloadSchema = zod.z.object({
+	digest: zod.z.string(),
+	remotes: zod.z.array(ComposeRemoteSchema),
+	manifests: zod.z.array(PluginManifestSchema)
+}).superRefine((payload, ctx) => {
+	for (const manifest of payload.manifests) if (manifest.manifestVersion !== 2) ctx.addIssue({
+		code: "custom",
+		message: manifestVersionIssue(manifest.name, manifest.manifestVersion)
+	});
+});
+
+//#endregion
+exports.ComposePayloadSchema = ComposePayloadSchema;
+exports.ComposeRemoteSchema = ComposeRemoteSchema;
+exports.MANIFEST_VERSION = MANIFEST_VERSION;
+exports.ManifestSchema = ManifestSchema;
+exports.PluginManifestSchema = PluginManifestSchema;
+exports.RouteRecordSchema = RouteRecordSchema;
+exports.SUPPORTED_MANIFEST_VERSION = SUPPORTED_MANIFEST_VERSION;
+exports.parsePluginManifest = parsePluginManifest;
+//# sourceMappingURL=manifest-schema.cjs.map

package/dist/ui/manifest/manifest-schema.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"manifest-schema.cjs","names":["z","MOUNTS"],"sources":["../../../src/ui/manifest/manifest-schema.ts"],"sourcesContent":["import { z } from \"zod\";\nimport { MOUNTS } from \"./mount-registry\";\n\n/**\n * manifest.gen.json — pure data emitted by the generator from route files\n * only (ADR 0008 §2). Nothing here is hand-maintained; this schema is the\n * composition contract and the audit/marketplace surface. The host refuses\n * unknown `manifestVersion` majors.\n */\n\n/**\n * The manifest contract major this code speaks. Emitted by the generator and\n * enforced at every load (the host parses through `parsePluginManifest`; the\n * client parse of the compose payload checks it — a skewed major degrades to\n * the core-only tree instead of silently mis-constructing).\n */\nexport const MANIFEST_VERSION = 2;\nexport const SUPPORTED_MANIFEST_VERSION = MANIFEST_VERSION;\n\nexport const RouteRecordSchema = z.object({\n  /** Full route id, root-relative, no leading slash. e.g. \"_public/login\" */\n  id: z.string(),\n  /** Node kind — the @tanstack/virtual-file-routes vocabulary. */\n  type: z.enum([\"route\", \"layout\", \"index\"]),\n  /** URL path relative to the parent; absent for pathless layouts. */\n  path: z.string().optional(),\n  /** id of the parent record within the same plugin; absent = mount-level. */\n  parentId: z.string().optional(),\n  /** Set on ROOT-level pathless layouts: the mount this subtree declares. */\n  mount: z.enum(MOUNTS as [string, ...string[]]).optional(),\n  /** Route file relative to the routes directory (options source). */\n  file: z.string().optional(),\n});\n\nexport const PluginManifestSchema = z.object({\n  /** Plugin key — derived from the workspace/config key by the emitter. */\n  name: z.string(),\n  /** Contract version — enforced by `parsePluginManifest` / the payload check. */\n  manifestVersion: z.number().int(),\n  /** Lifted from the plugin's `__root` route options, if any. */\n  rootMeta: z\n    .object({\n      hasHead: z.boolean().optional(),\n      hasStaticData: z.boolean().optional(),\n    })\n    .optional(),\n  routes: z.array(RouteRecordSchema),\n});\n\n/**\n * The load-time contract check — one diagnostic for a manifest from a\n * different framework major. Every manifest load goes through this.\n */\nexport function parsePluginManifest(data: unknown): PluginManifest {\n  const parsed = PluginManifestSchema.parse(data);\n  if (parsed.manifestVersion !== SUPPORTED_MANIFEST_VERSION) {\n    throw new Error(manifestVersionIssue(parsed.name, parsed.manifestVersion));\n  }\n  return parsed;\n}\n\nconst manifestVersionIssue = (name: string, found: number): string =>\n  `unsupported manifest version ${found} in \"${name}\" — this build speaks ${SUPPORTED_MANIFEST_VERSION}; regenerate manifest.gen.json with the installed framework`;\n\nexport const ManifestSchema = z.object({\n  manifestVersion: z.number().int(),\n  plugins: z.array(PluginManifestSchema),\n});\n\nexport type RouteRecord = z.infer<typeof RouteRecordSchema>;\nexport type PluginManifest = z.infer<typeof PluginManifestSchema>;\nexport type Manifest = z.infer<typeof ManifestSchema>;\n\n/**\n * The client compose payload — the runtime-config `ui.compose` block the\n * server embeds and the client reconstructs the tree from. Single home:\n * everything-dev's client-config schema, the hydrate client, and the host's\n * ui-compose all derive from this schema.\n */\nexport const ComposeRemoteSchema = z.object({\n  key: z.string(),\n  name: z.string(),\n  entry: z.string(),\n  /** the remote's (hashed) browser-manifest URL — preferred over deriving\n   * one from `entry` by stripping the legacy fixed entry name */\n  manifestUrl: z.string().optional(),\n});\n\nexport const ComposePayloadSchema = z\n  .object({\n    digest: z.string(),\n    remotes: z.array(ComposeRemoteSchema),\n    manifests: z.array(PluginManifestSchema),\n  })\n  .superRefine((payload, ctx) => {\n    for (const manifest of payload.manifests) {\n      if (manifest.manifestVersion !== SUPPORTED_MANIFEST_VERSION) {\n        ctx.addIssue({\n          code: \"custom\",\n          message: manifestVersionIssue(manifest.name, manifest.manifestVersion),\n        });\n      }\n    }\n  });\n\nexport type ComposeRemote = z.infer<typeof ComposeRemoteSchema>;\nexport type ComposePayload = z.infer<typeof ComposePayloadSchema>;\n"],"mappings":";;;;;;;;;;;;;;;;AAgBA,MAAa,mBAAmB;AAChC,MAAa;AAEb,MAAa,oBAAoBA,MAAE,OAAO;;CAExC,IAAIA,MAAE,OAAO;;CAEb,MAAMA,MAAE,KAAK;EAAC;EAAS;EAAU;CAAO,CAAC;;CAEzC,MAAMA,MAAE,OAAO,CAAC,CAAC,SAAS;;CAE1B,UAAUA,MAAE,OAAO,CAAC,CAAC,SAAS;;CAE9B,OAAOA,MAAE,KAAKC,6BAA+B,CAAC,CAAC,SAAS;;CAExD,MAAMD,MAAE,OAAO,CAAC,CAAC,SAAS;AAC5B,CAAC;AAED,MAAa,uBAAuBA,MAAE,OAAO;;CAE3C,MAAMA,MAAE,OAAO;;CAEf,iBAAiBA,MAAE,OAAO,CAAC,CAAC,IAAI;;CAEhC,UAAUA,MACP,OAAO;EACN,SAASA,MAAE,QAAQ,CAAC,CAAC,SAAS;EAC9B,eAAeA,MAAE,QAAQ,CAAC,CAAC,SAAS;CACtC,CAAC,CAAC,CACD,SAAS;CACZ,QAAQA,MAAE,MAAM,iBAAiB;AACnC,CAAC;;;;;AAMD,SAAgB,oBAAoB,MAA+B;CACjE,MAAM,SAAS,qBAAqB,MAAM,IAAI;CAC9C,IAAI,OAAO,uBACT,MAAM,IAAI,MAAM,qBAAqB,OAAO,MAAM,OAAO,eAAe,CAAC;CAE3E,OAAO;AACT;AAEA,MAAM,wBAAwB,MAAc,UAC1C,gCAAgC,MAAM,OAAO,KAAK,0BAAmD;AAEvG,MAAa,iBAAiBA,MAAE,OAAO;CACrC,iBAAiBA,MAAE,OAAO,CAAC,CAAC,IAAI;CAChC,SAASA,MAAE,MAAM,oBAAoB;AACvC,CAAC;;;;;;;AAYD,MAAa,sBAAsBA,MAAE,OAAO;CAC1C,KAAKA,MAAE,OAAO;CACd,MAAMA,MAAE,OAAO;CACf,OAAOA,MAAE,OAAO;;;CAGhB,aAAaA,MAAE,OAAO,CAAC,CAAC,SAAS;AACnC,CAAC;AAED,MAAa,uBAAuBA,MACjC,OAAO;CACN,QAAQA,MAAE,OAAO;CACjB,SAASA,MAAE,MAAM,mBAAmB;CACpC,WAAWA,MAAE,MAAM,oBAAoB;AACzC,CAAC,CAAC,CACD,aAAa,SAAS,QAAQ;CAC7B,KAAK,MAAM,YAAY,QAAQ,WAC7B,IAAI,SAAS,uBACX,IAAI,SAAS;EACX,MAAM;EACN,SAAS,qBAAqB,SAAS,MAAM,SAAS,eAAe;CACvE,CAAC;AAGP,CAAC"}

package/dist/ui/manifest/manifest-schema.d.cts

@@ -0,0 +1,132 @@
+import { z } from "zod";
+//#region src/ui/manifest/manifest-schema.d.ts
+/**
+ * manifest.gen.json — pure data emitted by the generator from route files
+ * only (ADR 0008 §2). Nothing here is hand-maintained; this schema is the
+ * composition contract and the audit/marketplace surface. The host refuses
+ * unknown `manifestVersion` majors.
+ */
+/**
+ * The manifest contract major this code speaks. Emitted by the generator and
+ * enforced at every load (the host parses through `parsePluginManifest`; the
+ * client parse of the compose payload checks it — a skewed major degrades to
+ * the core-only tree instead of silently mis-constructing).
+ */
+declare const MANIFEST_VERSION = 2;
+declare const SUPPORTED_MANIFEST_VERSION = 2;
+declare const RouteRecordSchema: z.ZodObject<{
+  id: z.ZodString;
+  type: z.ZodEnum<{
+    index: "index";
+    layout: "layout";
+    route: "route";
+  }>;
+  path: z.ZodOptional<z.ZodString>;
+  parentId: z.ZodOptional<z.ZodString>;
+  mount: z.ZodOptional<z.ZodEnum<{
+    [x: string]: string;
+  }>>;
+  file: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const PluginManifestSchema: z.ZodObject<{
+  name: z.ZodString;
+  manifestVersion: z.ZodNumber;
+  rootMeta: z.ZodOptional<z.ZodObject<{
+    hasHead: z.ZodOptional<z.ZodBoolean>;
+    hasStaticData: z.ZodOptional<z.ZodBoolean>;
+  }, z.core.$strip>>;
+  routes: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodEnum<{
+      index: "index";
+      layout: "layout";
+      route: "route";
+    }>;
+    path: z.ZodOptional<z.ZodString>;
+    parentId: z.ZodOptional<z.ZodString>;
+    mount: z.ZodOptional<z.ZodEnum<{
+      [x: string]: string;
+    }>>;
+    file: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * The load-time contract check — one diagnostic for a manifest from a
+ * different framework major. Every manifest load goes through this.
+ */
+declare function parsePluginManifest(data: unknown): PluginManifest;
+declare const ManifestSchema: z.ZodObject<{
+  manifestVersion: z.ZodNumber;
+  plugins: z.ZodArray<z.ZodObject<{
+    name: z.ZodString;
+    manifestVersion: z.ZodNumber;
+    rootMeta: z.ZodOptional<z.ZodObject<{
+      hasHead: z.ZodOptional<z.ZodBoolean>;
+      hasStaticData: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    routes: z.ZodArray<z.ZodObject<{
+      id: z.ZodString;
+      type: z.ZodEnum<{
+        index: "index";
+        layout: "layout";
+        route: "route";
+      }>;
+      path: z.ZodOptional<z.ZodString>;
+      parentId: z.ZodOptional<z.ZodString>;
+      mount: z.ZodOptional<z.ZodEnum<{
+        [x: string]: string;
+      }>>;
+      file: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+type RouteRecord = z.infer<typeof RouteRecordSchema>;
+type PluginManifest = z.infer<typeof PluginManifestSchema>;
+/**
+ * The client compose payload — the runtime-config `ui.compose` block the
+ * server embeds and the client reconstructs the tree from. Single home:
+ * everything-dev's client-config schema, the hydrate client, and the host's
+ * ui-compose all derive from this schema.
+ */
+declare const ComposeRemoteSchema: z.ZodObject<{
+  key: z.ZodString;
+  name: z.ZodString;
+  entry: z.ZodString;
+  manifestUrl: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const ComposePayloadSchema: z.ZodObject<{
+  digest: z.ZodString;
+  remotes: z.ZodArray<z.ZodObject<{
+    key: z.ZodString;
+    name: z.ZodString;
+    entry: z.ZodString;
+    manifestUrl: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
+  manifests: z.ZodArray<z.ZodObject<{
+    name: z.ZodString;
+    manifestVersion: z.ZodNumber;
+    rootMeta: z.ZodOptional<z.ZodObject<{
+      hasHead: z.ZodOptional<z.ZodBoolean>;
+      hasStaticData: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    routes: z.ZodArray<z.ZodObject<{
+      id: z.ZodString;
+      type: z.ZodEnum<{
+        index: "index";
+        layout: "layout";
+        route: "route";
+      }>;
+      path: z.ZodOptional<z.ZodString>;
+      parentId: z.ZodOptional<z.ZodString>;
+      mount: z.ZodOptional<z.ZodEnum<{
+        [x: string]: string;
+      }>>;
+      file: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+type ComposeRemote = z.infer<typeof ComposeRemoteSchema>;
+type ComposePayload = z.infer<typeof ComposePayloadSchema>;
+//#endregion
+export { ComposePayload, ComposePayloadSchema, ComposeRemote, ComposeRemoteSchema, MANIFEST_VERSION, ManifestSchema, PluginManifest, PluginManifestSchema, RouteRecord, RouteRecordSchema, SUPPORTED_MANIFEST_VERSION, parsePluginManifest };
+//# sourceMappingURL=manifest-schema.d.cts.map

package/dist/ui/manifest/manifest-schema.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manifest-schema.d.cts","names":[],"sources":["../../../src/ui/manifest/manifest-schema.ts"],"mappings":";;;;;;;;;;;;;;cAgBa;cACA;cAEA,mBAAiB,EAAA;;;;;;;;;;;;;GAa5B,EAAA,KAAA;cAEW,sBAAoB,EAAA;;;;;;;;;;;;;;;;;;;;;GAa/B,EAAA,KAAA;;;;;iBAMc,oBAAoB,gBAAgB;cAWvC,gBAAc,EAAA;;;;;;;;;;;;;;;;;;;;;;;;GAGzB,EAAA,KAAA;KAEU,cAAc,EAAE,aAAa;KAC7B,iBAAiB,EAAE,aAAa;;;;;;;cAS/B,qBAAmB,EAAA;;;;;GAO9B,EAAA,KAAA;cAEW,sBAAoB,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAe7B,EAAA,KAAA;KAEQ,gBAAgB,EAAE,aAAa;KAC/B,iBAAiB,EAAE,aAAa"}

package/dist/ui/manifest/manifest-schema.d.mts

@@ -0,0 +1,132 @@
+import { z } from "zod";
+//#region src/ui/manifest/manifest-schema.d.ts
+/**
+ * manifest.gen.json — pure data emitted by the generator from route files
+ * only (ADR 0008 §2). Nothing here is hand-maintained; this schema is the
+ * composition contract and the audit/marketplace surface. The host refuses
+ * unknown `manifestVersion` majors.
+ */
+/**
+ * The manifest contract major this code speaks. Emitted by the generator and
+ * enforced at every load (the host parses through `parsePluginManifest`; the
+ * client parse of the compose payload checks it — a skewed major degrades to
+ * the core-only tree instead of silently mis-constructing).
+ */
+declare const MANIFEST_VERSION = 2;
+declare const SUPPORTED_MANIFEST_VERSION = 2;
+declare const RouteRecordSchema: z.ZodObject<{
+  id: z.ZodString;
+  type: z.ZodEnum<{
+    index: "index";
+    layout: "layout";
+    route: "route";
+  }>;
+  path: z.ZodOptional<z.ZodString>;
+  parentId: z.ZodOptional<z.ZodString>;
+  mount: z.ZodOptional<z.ZodEnum<{
+    [x: string]: string;
+  }>>;
+  file: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const PluginManifestSchema: z.ZodObject<{
+  name: z.ZodString;
+  manifestVersion: z.ZodNumber;
+  rootMeta: z.ZodOptional<z.ZodObject<{
+    hasHead: z.ZodOptional<z.ZodBoolean>;
+    hasStaticData: z.ZodOptional<z.ZodBoolean>;
+  }, z.core.$strip>>;
+  routes: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodEnum<{
+      index: "index";
+      layout: "layout";
+      route: "route";
+    }>;
+    path: z.ZodOptional<z.ZodString>;
+    parentId: z.ZodOptional<z.ZodString>;
+    mount: z.ZodOptional<z.ZodEnum<{
+      [x: string]: string;
+    }>>;
+    file: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * The load-time contract check — one diagnostic for a manifest from a
+ * different framework major. Every manifest load goes through this.
+ */
+declare function parsePluginManifest(data: unknown): PluginManifest;
+declare const ManifestSchema: z.ZodObject<{
+  manifestVersion: z.ZodNumber;
+  plugins: z.ZodArray<z.ZodObject<{
+    name: z.ZodString;
+    manifestVersion: z.ZodNumber;
+    rootMeta: z.ZodOptional<z.ZodObject<{
+      hasHead: z.ZodOptional<z.ZodBoolean>;
+      hasStaticData: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    routes: z.ZodArray<z.ZodObject<{
+      id: z.ZodString;
+      type: z.ZodEnum<{
+        index: "index";
+        layout: "layout";
+        route: "route";
+      }>;
+      path: z.ZodOptional<z.ZodString>;
+      parentId: z.ZodOptional<z.ZodString>;
+      mount: z.ZodOptional<z.ZodEnum<{
+        [x: string]: string;
+      }>>;
+      file: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+type RouteRecord = z.infer<typeof RouteRecordSchema>;
+type PluginManifest = z.infer<typeof PluginManifestSchema>;
+/**
+ * The client compose payload — the runtime-config `ui.compose` block the
+ * server embeds and the client reconstructs the tree from. Single home:
+ * everything-dev's client-config schema, the hydrate client, and the host's
+ * ui-compose all derive from this schema.
+ */
+declare const ComposeRemoteSchema: z.ZodObject<{
+  key: z.ZodString;
+  name: z.ZodString;
+  entry: z.ZodString;
+  manifestUrl: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const ComposePayloadSchema: z.ZodObject<{
+  digest: z.ZodString;
+  remotes: z.ZodArray<z.ZodObject<{
+    key: z.ZodString;
+    name: z.ZodString;
+    entry: z.ZodString;
+    manifestUrl: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
+  manifests: z.ZodArray<z.ZodObject<{
+    name: z.ZodString;
+    manifestVersion: z.ZodNumber;
+    rootMeta: z.ZodOptional<z.ZodObject<{
+      hasHead: z.ZodOptional<z.ZodBoolean>;
+      hasStaticData: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    routes: z.ZodArray<z.ZodObject<{
+      id: z.ZodString;
+      type: z.ZodEnum<{
+        index: "index";
+        layout: "layout";
+        route: "route";
+      }>;
+      path: z.ZodOptional<z.ZodString>;
+      parentId: z.ZodOptional<z.ZodString>;
+      mount: z.ZodOptional<z.ZodEnum<{
+        [x: string]: string;
+      }>>;
+      file: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+type ComposeRemote = z.infer<typeof ComposeRemoteSchema>;
+type ComposePayload = z.infer<typeof ComposePayloadSchema>;
+//#endregion
+export { ComposePayload, ComposePayloadSchema, ComposeRemote, ComposeRemoteSchema, MANIFEST_VERSION, ManifestSchema, PluginManifest, PluginManifestSchema, RouteRecord, RouteRecordSchema, SUPPORTED_MANIFEST_VERSION, parsePluginManifest };
+//# sourceMappingURL=manifest-schema.d.mts.map

package/dist/ui/manifest/manifest-schema.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manifest-schema.d.mts","names":[],"sources":["../../../src/ui/manifest/manifest-schema.ts"],"mappings":";;;;;;;;;;;;;;cAgBa;cACA;cAEA,mBAAiB,EAAA;;;;;;;;;;;;;GAa5B,EAAA,KAAA;cAEW,sBAAoB,EAAA;;;;;;;;;;;;;;;;;;;;;GAa/B,EAAA,KAAA;;;;;iBAMc,oBAAoB,gBAAgB;cAWvC,gBAAc,EAAA;;;;;;;;;;;;;;;;;;;;;;;;GAGzB,EAAA,KAAA;KAEU,cAAc,EAAE,aAAa;KAC7B,iBAAiB,EAAE,aAAa;;;;;;;cAS/B,qBAAmB,EAAA;;;;;GAO9B,EAAA,KAAA;cAEW,sBAAoB,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAe7B,EAAA,KAAA;KAEQ,gBAAgB,EAAE,aAAa;KAC/B,iBAAiB,EAAE,aAAa"}

package/dist/ui/manifest/manifest-schema.mjs

@@ -0,0 +1,90 @@
+import { MOUNTS } from "./mount-registry.mjs";
+import { z } from "zod";
+
+//#region src/ui/manifest/manifest-schema.ts
+/**
+* manifest.gen.json — pure data emitted by the generator from route files
+* only (ADR 0008 §2). Nothing here is hand-maintained; this schema is the
+* composition contract and the audit/marketplace surface. The host refuses
+* unknown `manifestVersion` majors.
+*/
+/**
+* The manifest contract major this code speaks. Emitted by the generator and
+* enforced at every load (the host parses through `parsePluginManifest`; the
+* client parse of the compose payload checks it — a skewed major degrades to
+* the core-only tree instead of silently mis-constructing).
+*/
+const MANIFEST_VERSION = 2;
+const SUPPORTED_MANIFEST_VERSION = 2;
+const RouteRecordSchema = z.object({
+	/** Full route id, root-relative, no leading slash. e.g. "_public/login" */
+	id: z.string(),
+	/** Node kind — the @tanstack/virtual-file-routes vocabulary. */
+	type: z.enum([
+		"route",
+		"layout",
+		"index"
+	]),
+	/** URL path relative to the parent; absent for pathless layouts. */
+	path: z.string().optional(),
+	/** id of the parent record within the same plugin; absent = mount-level. */
+	parentId: z.string().optional(),
+	/** Set on ROOT-level pathless layouts: the mount this subtree declares. */
+	mount: z.enum(MOUNTS).optional(),
+	/** Route file relative to the routes directory (options source). */
+	file: z.string().optional()
+});
+const PluginManifestSchema = z.object({
+	/** Plugin key — derived from the workspace/config key by the emitter. */
+	name: z.string(),
+	/** Contract version — enforced by `parsePluginManifest` / the payload check. */
+	manifestVersion: z.number().int(),
+	/** Lifted from the plugin's `__root` route options, if any. */
+	rootMeta: z.object({
+		hasHead: z.boolean().optional(),
+		hasStaticData: z.boolean().optional()
+	}).optional(),
+	routes: z.array(RouteRecordSchema)
+});
+/**
+* The load-time contract check — one diagnostic for a manifest from a
+* different framework major. Every manifest load goes through this.
+*/
+function parsePluginManifest(data) {
+	const parsed = PluginManifestSchema.parse(data);
+	if (parsed.manifestVersion !== 2) throw new Error(manifestVersionIssue(parsed.name, parsed.manifestVersion));
+	return parsed;
+}
+const manifestVersionIssue = (name, found) => `unsupported manifest version ${found} in "${name}" — this build speaks ${2}; regenerate manifest.gen.json with the installed framework`;
+const ManifestSchema = z.object({
+	manifestVersion: z.number().int(),
+	plugins: z.array(PluginManifestSchema)
+});
+/**
+* The client compose payload — the runtime-config `ui.compose` block the
+* server embeds and the client reconstructs the tree from. Single home:
+* everything-dev's client-config schema, the hydrate client, and the host's
+* ui-compose all derive from this schema.
+*/
+const ComposeRemoteSchema = z.object({
+	key: z.string(),
+	name: z.string(),
+	entry: z.string(),
+	/** the remote's (hashed) browser-manifest URL — preferred over deriving
+	* one from `entry` by stripping the legacy fixed entry name */
+	manifestUrl: z.string().optional()
+});
+const ComposePayloadSchema = z.object({
+	digest: z.string(),
+	remotes: z.array(ComposeRemoteSchema),
+	manifests: z.array(PluginManifestSchema)
+}).superRefine((payload, ctx) => {
+	for (const manifest of payload.manifests) if (manifest.manifestVersion !== 2) ctx.addIssue({
+		code: "custom",
+		message: manifestVersionIssue(manifest.name, manifest.manifestVersion)
+	});
+});
+
+//#endregion
+export { ComposePayloadSchema, ComposeRemoteSchema, MANIFEST_VERSION, ManifestSchema, PluginManifestSchema, RouteRecordSchema, SUPPORTED_MANIFEST_VERSION, parsePluginManifest };
+//# sourceMappingURL=manifest-schema.mjs.map

package/dist/ui/manifest/manifest-schema.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"manifest-schema.mjs","names":[],"sources":["../../../src/ui/manifest/manifest-schema.ts"],"sourcesContent":["import { z } from \"zod\";\nimport { MOUNTS } from \"./mount-registry\";\n\n/**\n * manifest.gen.json — pure data emitted by the generator from route files\n * only (ADR 0008 §2). Nothing here is hand-maintained; this schema is the\n * composition contract and the audit/marketplace surface. The host refuses\n * unknown `manifestVersion` majors.\n */\n\n/**\n * The manifest contract major this code speaks. Emitted by the generator and\n * enforced at every load (the host parses through `parsePluginManifest`; the\n * client parse of the compose payload checks it — a skewed major degrades to\n * the core-only tree instead of silently mis-constructing).\n */\nexport const MANIFEST_VERSION = 2;\nexport const SUPPORTED_MANIFEST_VERSION = MANIFEST_VERSION;\n\nexport const RouteRecordSchema = z.object({\n  /** Full route id, root-relative, no leading slash. e.g. \"_public/login\" */\n  id: z.string(),\n  /** Node kind — the @tanstack/virtual-file-routes vocabulary. */\n  type: z.enum([\"route\", \"layout\", \"index\"]),\n  /** URL path relative to the parent; absent for pathless layouts. */\n  path: z.string().optional(),\n  /** id of the parent record within the same plugin; absent = mount-level. */\n  parentId: z.string().optional(),\n  /** Set on ROOT-level pathless layouts: the mount this subtree declares. */\n  mount: z.enum(MOUNTS as [string, ...string[]]).optional(),\n  /** Route file relative to the routes directory (options source). */\n  file: z.string().optional(),\n});\n\nexport const PluginManifestSchema = z.object({\n  /** Plugin key — derived from the workspace/config key by the emitter. */\n  name: z.string(),\n  /** Contract version — enforced by `parsePluginManifest` / the payload check. */\n  manifestVersion: z.number().int(),\n  /** Lifted from the plugin's `__root` route options, if any. */\n  rootMeta: z\n    .object({\n      hasHead: z.boolean().optional(),\n      hasStaticData: z.boolean().optional(),\n    })\n    .optional(),\n  routes: z.array(RouteRecordSchema),\n});\n\n/**\n * The load-time contract check — one diagnostic for a manifest from a\n * different framework major. Every manifest load goes through this.\n */\nexport function parsePluginManifest(data: unknown): PluginManifest {\n  const parsed = PluginManifestSchema.parse(data);\n  if (parsed.manifestVersion !== SUPPORTED_MANIFEST_VERSION) {\n    throw new Error(manifestVersionIssue(parsed.name, parsed.manifestVersion));\n  }\n  return parsed;\n}\n\nconst manifestVersionIssue = (name: string, found: number): string =>\n  `unsupported manifest version ${found} in \"${name}\" — this build speaks ${SUPPORTED_MANIFEST_VERSION}; regenerate manifest.gen.json with the installed framework`;\n\nexport const ManifestSchema = z.object({\n  manifestVersion: z.number().int(),\n  plugins: z.array(PluginManifestSchema),\n});\n\nexport type RouteRecord = z.infer<typeof RouteRecordSchema>;\nexport type PluginManifest = z.infer<typeof PluginManifestSchema>;\nexport type Manifest = z.infer<typeof ManifestSchema>;\n\n/**\n * The client compose payload — the runtime-config `ui.compose` block the\n * server embeds and the client reconstructs the tree from. Single home:\n * everything-dev's client-config schema, the hydrate client, and the host's\n * ui-compose all derive from this schema.\n */\nexport const ComposeRemoteSchema = z.object({\n  key: z.string(),\n  name: z.string(),\n  entry: z.string(),\n  /** the remote's (hashed) browser-manifest URL — preferred over deriving\n   * one from `entry` by stripping the legacy fixed entry name */\n  manifestUrl: z.string().optional(),\n});\n\nexport const ComposePayloadSchema = z\n  .object({\n    digest: z.string(),\n    remotes: z.array(ComposeRemoteSchema),\n    manifests: z.array(PluginManifestSchema),\n  })\n  .superRefine((payload, ctx) => {\n    for (const manifest of payload.manifests) {\n      if (manifest.manifestVersion !== SUPPORTED_MANIFEST_VERSION) {\n        ctx.addIssue({\n          code: \"custom\",\n          message: manifestVersionIssue(manifest.name, manifest.manifestVersion),\n        });\n      }\n    }\n  });\n\nexport type ComposeRemote = z.infer<typeof ComposeRemoteSchema>;\nexport type ComposePayload = z.infer<typeof ComposePayloadSchema>;\n"],"mappings":";;;;;;;;;;;;;;;;AAgBA,MAAa,mBAAmB;AAChC,MAAa;AAEb,MAAa,oBAAoB,EAAE,OAAO;;CAExC,IAAI,EAAE,OAAO;;CAEb,MAAM,EAAE,KAAK;EAAC;EAAS;EAAU;CAAO,CAAC;;CAEzC,MAAM,EAAE,OAAO,CAAC,CAAC,SAAS;;CAE1B,UAAU,EAAE,OAAO,CAAC,CAAC,SAAS;;CAE9B,OAAO,EAAE,KAAK,MAA+B,CAAC,CAAC,SAAS;;CAExD,MAAM,EAAE,OAAO,CAAC,CAAC,SAAS;AAC5B,CAAC;AAED,MAAa,uBAAuB,EAAE,OAAO;;CAE3C,MAAM,EAAE,OAAO;;CAEf,iBAAiB,EAAE,OAAO,CAAC,CAAC,IAAI;;CAEhC,UAAU,EACP,OAAO;EACN,SAAS,EAAE,QAAQ,CAAC,CAAC,SAAS;EAC9B,eAAe,EAAE,QAAQ,CAAC,CAAC,SAAS;CACtC,CAAC,CAAC,CACD,SAAS;CACZ,QAAQ,EAAE,MAAM,iBAAiB;AACnC,CAAC;;;;;AAMD,SAAgB,oBAAoB,MAA+B;CACjE,MAAM,SAAS,qBAAqB,MAAM,IAAI;CAC9C,IAAI,OAAO,uBACT,MAAM,IAAI,MAAM,qBAAqB,OAAO,MAAM,OAAO,eAAe,CAAC;CAE3E,OAAO;AACT;AAEA,MAAM,wBAAwB,MAAc,UAC1C,gCAAgC,MAAM,OAAO,KAAK,0BAAmD;AAEvG,MAAa,iBAAiB,EAAE,OAAO;CACrC,iBAAiB,EAAE,OAAO,CAAC,CAAC,IAAI;CAChC,SAAS,EAAE,MAAM,oBAAoB;AACvC,CAAC;;;;;;;AAYD,MAAa,sBAAsB,EAAE,OAAO;CAC1C,KAAK,EAAE,OAAO;CACd,MAAM,EAAE,OAAO;CACf,OAAO,EAAE,OAAO;;;CAGhB,aAAa,EAAE,OAAO,CAAC,CAAC,SAAS;AACnC,CAAC;AAED,MAAa,uBAAuB,EACjC,OAAO;CACN,QAAQ,EAAE,OAAO;CACjB,SAAS,EAAE,MAAM,mBAAmB;CACpC,WAAW,EAAE,MAAM,oBAAoB;AACzC,CAAC,CAAC,CACD,aAAa,SAAS,QAAQ;CAC7B,KAAK,MAAM,YAAY,QAAQ,WAC7B,IAAI,SAAS,uBACX,IAAI,SAAS;EACX,MAAM;EACN,SAAS,qBAAqB,SAAS,MAAM,SAAS,eAAe;CACvE,CAAC;AAGP,CAAC"}

package/dist/ui/manifest/mount-registry.cjs

@@ -0,0 +1,52 @@
+//#region src/ui/manifest/mount-registry.ts
+const MOUNT_REGISTRY = {
+	public: {
+		label: "public",
+		gate: "none",
+		implemented: true
+	},
+	authenticated: {
+		label: "authenticated",
+		gate: "session",
+		implemented: true
+	},
+	admin: {
+		label: "admin",
+		gate: "admin",
+		implemented: true
+	},
+	org: {
+		label: "org",
+		gate: "organization",
+		parameterized: true,
+		implemented: false
+	},
+	team: {
+		label: "team",
+		gate: "team",
+		parameterized: true,
+		implemented: false
+	}
+};
+const MOUNTS = Object.keys(MOUNT_REGISTRY);
+/** Bump when the registry shape changes — invalidates all compose digests. */
+const MOUNT_REGISTRY_VERSION = 5;
+/** Migration aliases: legacy `_`-segment names → canonical mounts. */
+const MOUNT_ALIASES = {
+	auth: "authenticated",
+	authed: "authenticated",
+	dashboard: "authenticated",
+	organization: "org"
+};
+function resolveMountSegment(segment) {
+	if (segment in MOUNT_REGISTRY) return segment;
+	return MOUNT_ALIASES[segment];
+}
+
+//#endregion
+exports.MOUNTS = MOUNTS;
+exports.MOUNT_ALIASES = MOUNT_ALIASES;
+exports.MOUNT_REGISTRY = MOUNT_REGISTRY;
+exports.MOUNT_REGISTRY_VERSION = MOUNT_REGISTRY_VERSION;
+exports.resolveMountSegment = resolveMountSegment;
+//# sourceMappingURL=mount-registry.cjs.map

package/dist/ui/manifest/mount-registry.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"mount-registry.cjs","names":[],"sources":["../../../src/ui/manifest/mount-registry.ts"],"sourcesContent":["/**\n * Mount registry v2 — gates only, shape-free (ADR 0008 §3).\n *\n * A mount is a gate + a host-owned pathless layout position. It carries no\n * product semantics (no \"dashboard\", no shell, no chrome) — plugins bring\n * their own layouts and route freely inside their subtree. A mount is\n * declared by a ROOT-level pathless layout file whose `_`-prefixed segment\n * names the mount (`_public.tsx` → `public`); the generator derives it and\n * validates it against this registry; gates are attached HOST-side at\n * construction, so a plugin cannot ship a route that escapes its mount's\n * gate (plugins never construct route objects).\n *\n * `org`/`team` are declared vocabulary (parameterized membership gates) but\n * unimplemented — construction rejects them until they land.\n */\n\nexport interface MountDef {\n  label: string;\n  gate: \"none\" | \"session\" | \"admin\" | \"organization\" | \"team\";\n  parameterized?: boolean;\n  implemented: boolean;\n}\n\nexport const MOUNT_REGISTRY = {\n  public: { label: \"public\", gate: \"none\", implemented: true },\n  authenticated: { label: \"authenticated\", gate: \"session\", implemented: true },\n  admin: { label: \"admin\", gate: \"admin\", implemented: true },\n  org: { label: \"org\", gate: \"organization\", parameterized: true, implemented: false },\n  team: { label: \"team\", gate: \"team\", parameterized: true, implemented: false },\n} satisfies Record<string, MountDef>;\n\nexport type MountId = Extract<keyof typeof MOUNT_REGISTRY, string>;\n\nexport const MOUNTS = Object.keys(MOUNT_REGISTRY) as MountId[];\n\n/** Bump when the registry shape changes — invalidates all compose digests. */\nexport const MOUNT_REGISTRY_VERSION = 5;\n\n/** Migration aliases: legacy `_`-segment names → canonical mounts. */\nexport const MOUNT_ALIASES: Record<string, MountId> = {\n  auth: \"authenticated\",\n  authed: \"authenticated\",\n  dashboard: \"authenticated\",\n  organization: \"org\",\n};\n\nexport function resolveMountSegment(segment: string): MountId | undefined {\n  if (segment in MOUNT_REGISTRY) return segment as MountId;\n  return MOUNT_ALIASES[segment];\n}\n"],"mappings":";AAuBA,MAAa,iBAAiB;CAC5B,QAAQ;EAAE,OAAO;EAAU,MAAM;EAAQ,aAAa;CAAK;CAC3D,eAAe;EAAE,OAAO;EAAiB,MAAM;EAAW,aAAa;CAAK;CAC5E,OAAO;EAAE,OAAO;EAAS,MAAM;EAAS,aAAa;CAAK;CAC1D,KAAK;EAAE,OAAO;EAAO,MAAM;EAAgB,eAAe;EAAM,aAAa;CAAM;CACnF,MAAM;EAAE,OAAO;EAAQ,MAAM;EAAQ,eAAe;EAAM,aAAa;CAAM;AAC/E;AAIA,MAAa,SAAS,OAAO,KAAK,cAAc;;AAGhD,MAAa,yBAAyB;;AAGtC,MAAa,gBAAyC;CACpD,MAAM;CACN,QAAQ;CACR,WAAW;CACX,cAAc;AAChB;AAEA,SAAgB,oBAAoB,SAAsC;CACxE,IAAI,WAAW,gBAAgB,OAAO;CACtC,OAAO,cAAc;AACvB"}

package/dist/ui/manifest/mount-registry.d.cts

@@ -0,0 +1,61 @@
+//#region src/ui/manifest/mount-registry.d.ts
+/**
+ * Mount registry v2 — gates only, shape-free (ADR 0008 §3).
+ *
+ * A mount is a gate + a host-owned pathless layout position. It carries no
+ * product semantics (no "dashboard", no shell, no chrome) — plugins bring
+ * their own layouts and route freely inside their subtree. A mount is
+ * declared by a ROOT-level pathless layout file whose `_`-prefixed segment
+ * names the mount (`_public.tsx` → `public`); the generator derives it and
+ * validates it against this registry; gates are attached HOST-side at
+ * construction, so a plugin cannot ship a route that escapes its mount's
+ * gate (plugins never construct route objects).
+ *
+ * `org`/`team` are declared vocabulary (parameterized membership gates) but
+ * unimplemented — construction rejects them until they land.
+ */
+interface MountDef {
+  label: string;
+  gate: "none" | "session" | "admin" | "organization" | "team";
+  parameterized?: boolean;
+  implemented: boolean;
+}
+declare const MOUNT_REGISTRY: {
+  public: {
+    label: string;
+    gate: "none";
+    implemented: true;
+  };
+  authenticated: {
+    label: string;
+    gate: "session";
+    implemented: true;
+  };
+  admin: {
+    label: string;
+    gate: "admin";
+    implemented: true;
+  };
+  org: {
+    label: string;
+    gate: "organization";
+    parameterized: true;
+    implemented: false;
+  };
+  team: {
+    label: string;
+    gate: "team";
+    parameterized: true;
+    implemented: false;
+  };
+};
+type MountId = Extract<keyof typeof MOUNT_REGISTRY, string>;
+declare const MOUNTS: MountId[];
+/** Bump when the registry shape changes — invalidates all compose digests. */
+declare const MOUNT_REGISTRY_VERSION = 5;
+/** Migration aliases: legacy `_`-segment names → canonical mounts. */
+declare const MOUNT_ALIASES: Record<string, MountId>;
+declare function resolveMountSegment(segment: string): MountId | undefined;
+//#endregion
+export { MOUNTS, MOUNT_ALIASES, MOUNT_REGISTRY, MOUNT_REGISTRY_VERSION, MountDef, MountId, resolveMountSegment };
+//# sourceMappingURL=mount-registry.d.cts.map

package/dist/ui/manifest/mount-registry.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mount-registry.d.cts","names":[],"sources":["../../../src/ui/manifest/mount-registry.ts"],"mappings":";;;;;;;;;;;;;;;;UAgBiB;EACf;EACA;EACA;EACA;;cAGW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAQD,UAAU,qBAAqB;cAE9B,QAAwC;;cAGxC;;cAGA,eAAe,eAAe;iBAO3B,oBAAoB,kBAAkB"}