@wairon/cli 5.1.1-dev.79 → 5.1.1-dev.80

package/dist/index.js

@@ -3451,7 +3451,9 @@ __export(src_exports, {
   NarrativeStepTypeSchema: () => NarrativeStepTypeSchema,
   OutputTargetSchema: () => OutputTargetSchema,
   PATTERN_TYPES: () => PATTERN_TYPES,
+  PROJECT_ID_RE: () => PROJECT_ID_RE,
   PROJECT_KINDS: () => PROJECT_KINDS,
+  PUBLIC_NAME_RE: () => PUBLIC_NAME_RE,
   PackSelectionSchema: () => PackSelectionSchema,
   ParallelBranchSchema: () => ParallelBranchSchema,
   PathsConfigSchema: () => PathsConfigSchema,
@@ -3486,6 +3488,7 @@ __export(src_exports, {
   SurfaceOriginSchema: () => SurfaceOriginSchema,
   SurfaceSnapshotSchema: () => SurfaceSnapshotSchema,
   SurfaceTypeDefSchema: () => SurfaceTypeDefSchema,
+  SurfaceTypeExportSchema: () => SurfaceTypeExportSchema,
   SwitchCaseSchema: () => SwitchCaseSchema,
   SystemPublicInterfaceSchema: () => SystemPublicInterfaceSchema,
   SystemSpecSchema: () => SystemSpecSchema,
@@ -3556,10 +3559,12 @@ __export(src_exports, {
   discoverPacks: () => discoverPacks,
   dryRunSerializeSpecs: () => dryRunSerializeSpecs,
   effectiveDetail: () => effectiveDetail,
+  effectiveProjectId: () => effectiveProjectId,
   emptyExtensions: () => emptyExtensions,
   ensureDir: () => ensureDir,
   ensureProjectInitialized: () => ensureProjectInitialized,
   exportSpecTree: () => exportSpecTree,
+  exportTargetKey: () => exportTargetKey,
   externalizeSubsystem: () => externalizeSubsystem,
   extractTypeIdentifiers: () => extractTypeIdentifiers,
   factsFor: () => factsFor,
@@ -3600,6 +3605,7 @@ __export(src_exports, {
   internalizeSubsystem: () => internalizeSubsystem,
   isDraftSubsystem: () => isDraftSubsystem,
   isLogic: () => isLogic,
+  isOwnComponentEntry: () => isOwnComponentEntry,
   isPattern: () => isPattern,
   isProjectInitialized: () => isProjectInitialized,
   isProvidedBy: () => isProvidedBy,
@@ -3653,6 +3659,7 @@ __export(src_exports, {
   pathKey: () => pathKey,
   pinInstalledPacksAsSelections: () => pinInstalledPacksAsSelections,
   projectConfigExists: () => projectConfigExists,
+  projectIdentity: () => projectIdentity,
   provisionProject: () => provisionProject,
   qualifiedTypeId: () => qualifiedTypeId,
   readFileOrNull: () => readFileOrNull,
@@ -3678,7 +3685,9 @@ __export(src_exports, {
   resolveExpectedOutputPaths: () => resolveExpectedOutputPaths,
   resolveImport: () => resolveImport,
   resolveInstalledPack: () => resolveInstalledPack,
+  resolveProjectExports: () => resolveProjectExports,
   resolveSubprojectForNamespace: () => resolveSubprojectForNamespace,
+  resolveSubsystemExports: () => resolveSubsystemExports,
   resolveVariantGuidance: () => resolveVariantGuidance,
   retireSpecialists: () => retireSpecialists,
   runWithProjectBinding: () => runWithProjectBinding,
@@ -4462,7 +4471,16 @@ var ProjectConfigSchema = import_zod3.z.object({
    * CLI versions.
    */
   schemaVersion: import_zod3.z.string().default("1.0.0"),
-  /** Human-readable project name */
+  /**
+   * The project's stable identity: a slug of [a-z0-9-_.] that starts and ends
+   * alphanumeric (PROJECT_ID_RE). Optional in the file: a project that declares
+   * none answers to its name slugified (effectiveProjectId) until a deliberate
+   * writer sets one — an ordinary save never writes the default. Deliberately a plain
+   * string here rather than the grammar: a malformed id must be REPORTED
+   * (PROJECT_ID_AMBIGUOUS), not make the whole configuration unreadable.
+   */
+  id: import_zod3.z.string().optional(),
+  /** Human-readable display name. Not an identity — `id` is. */
   name: import_zod3.z.string(),
   /**
    * The type/profile of the project, which configures targeted guidelines, rules,
@@ -4571,6 +4589,40 @@ function declaredPackNames(config) {
 function declaredProfileIds(config) {
   return [...new Set(config.profileSelection?.profileIds ?? [])];
 }
+var PROJECT_ID_RE = /^[a-z0-9](?:[a-z0-9._-]*[a-z0-9])?$/;
+function slugifyProjectName(name) {
+  const slug = name.toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^[^a-z0-9]+/, "").replace(/[^a-z0-9]+$/, "");
+  return slug === "" ? null : slug;
+}
+function effectiveProjectId(config) {
+  if (config.id !== void 0) return config.id;
+  return slugifyProjectName(config.name);
+}
+function projectIdentity(config, lockedProjectId) {
+  const id = effectiveProjectId(config);
+  const source = config.id !== void 0 ? "declared" : id !== null ? "defaulted" : "none";
+  const problems = [];
+  if (source === "defaulted") {
+    problems.push({ kind: "defaulted", detail: `no id is declared; the name "${config.name}" yields "${id}"` });
+  } else if (source === "none") {
+    problems.push({ kind: "ambiguous", detail: `no id is declared, and the name "${config.name}" yields no id` });
+  } else if (!PROJECT_ID_RE.test(config.id)) {
+    problems.push({ kind: "ambiguous", detail: `the declared id "${config.id}" breaks the project-id grammar` });
+  }
+  if (lockedProjectId !== void 0 && id !== lockedProjectId) {
+    problems.push({
+      kind: "changed",
+      detail: id === null ? `the lock approved "${lockedProjectId}", and the project now has no id` : `the lock approved "${lockedProjectId}", and the project now resolves to "${id}"`
+    });
+  }
+  return {
+    ...id !== null ? { id } : {},
+    source,
+    name: config.name,
+    ...lockedProjectId !== void 0 ? { lockedId: lockedProjectId } : {},
+    problems
+  };
+}
 
 // src/config/project-config.ts
 function waiDirAt(root) {
@@ -4858,18 +4910,19 @@ function registryOver(store, root) {
     if (!config) throw new ProjectNotInitializedError();
     return config;
   };
+  const save = (config) => store.write(config);
   return {
     create(config) {
       if (store.exists()) {
         throw new WaironError(`A project configuration already exists at ${root}; creating one never overwrites it.`);
       }
-      store.write(config);
+      save(config);
     },
     upsertPackSelection(selection) {
       const config = current2();
       const existing = packsOf(config);
       const without = existing.filter((entry) => typeof entry === "string" || entry.name !== selection.name);
-      store.write(withPacks(config, [...without, selection]));
+      save(withPacks(config, [...without, selection]));
       return without.length !== existing.length;
     },
     removePackSelection(packName) {
@@ -4877,24 +4930,24 @@ function registryOver(store, root) {
       const existing = packsOf(config);
       const remaining = existing.filter((entry) => typeof entry === "string" || entry.name !== packName);
       if (remaining.length === existing.length) return false;
-      store.write(withPacks(config, remaining));
+      save(withPacks(config, remaining));
       return true;
     },
     setProjectType(projectType) {
-      store.write({ ...current2(), projectType });
+      save({ ...current2(), projectType });
     },
     recordProfileSelection(selection) {
-      store.write({ ...current2(), profileSelection: selection });
+      save({ ...current2(), profileSelection: selection });
     },
     setExecutionTier(tier) {
       const config = current2();
-      store.write({ ...config, execution: { ...config.execution, tier } });
+      save({ ...config, execution: { ...config.execution, tier } });
     },
     registerPackRef(ref) {
       const config = current2();
       const packs = packsOf(config);
       if (packs.includes(ref)) return false;
-      store.write(withPacks(config, [...packs, ref]));
+      save(withPacks(config, [...packs, ref]));
       return true;
     },
     deregisterPackRef(ref) {
@@ -4902,16 +4955,16 @@ function registryOver(store, root) {
       const packs = packsOf(config);
       const remaining = packs.filter((entry) => entry !== ref);
       if (remaining.length === packs.length) return false;
-      store.write(withPacks(config, remaining));
+      save(withPacks(config, remaining));
       return true;
     },
     markSelectionsBundled(bundled) {
       const config = current2();
-      store.write(withPacks(config, bundleInPlace(packsOf(config), bundled)));
+      save(withPacks(config, bundleInPlace(packsOf(config), bundled)));
     },
     pinGlobalPacksAsSelections(selections) {
       const config = current2();
-      store.write({
+      save({
         ...config,
         extensions: { ...config.extensions, packs: [...packsOf(config), ...selections], useGlobalPacks: false }
       });
@@ -5406,15 +5459,21 @@ var DiagramConfigSchema = import_zod8.z.object({
 var SURFACE_AUDIENCES = ["project", "department", "instance", "partner", "external"];
 var SurfaceAudienceSchema = import_zod8.z.enum(SURFACE_AUDIENCES);
 var SystemPublicInterfaceSchema = import_zod8.z.object({
-  /** Stable public interface id within the system. */
+  /** Legacy public name, read as `as` when `as` is absent. */
   id: import_zod8.z.string().optional(),
   name: import_zod8.z.string().optional(),
-  /** Subsystem publishing the backing L1 public interface. */
+  /** Legacy source subsystem, read as `from` when `from` is absent. */
   subsystem: import_zod8.z.string().optional(),
-  /** Portal (or compatible published component) backing this entry. */
+  /** The component re-exported one to one; without it and without `typeDef`, a wildcard. */
   component: import_zod8.z.string().optional(),
-  /** Optional L3 interface id backing the surface. */
+  /** The L3 interface the export narrows to. */
   interface: import_zod8.z.string().optional(),
+  /** The source subsystem the entry re-exports from. */
+  from: import_zod8.z.string().optional(),
+  /** A type exported as is, giving it a public name. */
+  typeDef: import_zod8.z.string().optional(),
+  /** The public name: defaults to `id`, then `interface`, then `component` or `typeDef`. */
+  as: import_zod8.z.string().optional(),
   /** Surface kind: REST, GraphQL, MessageBus, RPC, or Custom. */
   type: import_zod8.z.string().optional(),
   details: import_zod8.z.string().optional(),
@@ -5455,19 +5514,33 @@ var SystemSpecSchema = import_zod8.z.object({
 });
 var PublicInterfaceTypeSchema = import_zod8.z.enum(["REST", "GraphQL", "MessageBus", "RPC", "Custom"]);
 var PublicInterfaceSchema = import_zod8.z.object({
-  type: PublicInterfaceTypeSchema,
-  details: import_zod8.z.string(),
-  /** The L2 component that realizes this public interface (the subsystem's published surface). */
+  /** Transport kind of an own item; a re-export inherits its target's. */
+  type: PublicInterfaceTypeSchema.optional(),
+  /** Consumer-facing description of an own item; a re-export inherits its target's. */
+  details: import_zod8.z.string().optional(),
+  /** For an own item, the L2 component that realizes it; for a re-export, the component re-exported from `from`. */
   component: SpecIdSchema.optional(),
-  /** Optional L3 interface on that component backing this entry. */
+  /** Optional L3 interface the entry narrows to. */
   interface: SpecIdSchema.optional(),
+  /** Re-export source: another subsystem of the same project. */
+  from: SpecIdSchema.optional(),
+  /** A type exported as is: owned by this subsystem, or re-exported from `from`. */
+  typeDef: SpecIdSchema.optional(),
+  /** The public name; defaults to the narrowed interface, then the component or type id. */
+  as: import_zod8.z.string().optional(),
   /**
    * The subsystems this surface is published to. Absent, anyone may depend on
    * it; present, only these subsystems may — when every entry publishing the
    * component names consumers, the union of those lists is the whole set.
    */
   consumers: import_zod8.z.array(SpecIdSchema).optional()
+}).refine((pi) => pi.from !== void 0 || pi.typeDef !== void 0 || pi.type !== void 0 && pi.details !== void 0, {
+  message: "An own component entry states its `type` and `details`; only a re-export (`from`) or a type export (`typeDef`) may leave them out.",
+  path: ["type"]
 });
+function isOwnComponentEntry(pi) {
+  return pi.from === void 0 && pi.typeDef === void 0;
+}
 var TrustedLinkSchema = import_zod8.z.object({
   /** The peer subsystem id this link sanctions tight coupling with. */
   subsystem: SpecIdSchema,
@@ -5784,8 +5857,8 @@ var MethodParamSchema = import_zod8.z.object({
 var FindingDeclarationSchema = import_zod8.z.object({
   /** UPPER_SNAKE and unique within the method; a pack's codes carry the pack prefix (<PACK>_<CODE>). */
   code: import_zod8.z.string().regex(/^[A-Z][A-Z0-9_]*$/, "Finding code must be UPPER_SNAKE, e.g. UNREALIZED_FINDING"),
-  /** The default before project severity overrides and draft-context downgrades. */
-  severity: import_zod8.z.enum(["error", "warning"]),
+  /** The default before project severity overrides and draft-context downgrades; a notice is reported but never fails the gate. */
+  severity: import_zod8.z.enum(["error", "warning", "notice"]),
   /** One line saying what the finding means. */
   summary: import_zod8.z.string().min(1, "Finding summary must say what the finding means")
 });
@@ -6329,6 +6402,14 @@ var SurfaceTypeDefSchema = import_zod8.z.object({
     optional: import_zod8.z.boolean().optional()
   })).default([])
 });
+var SurfaceTypeExportSchema = import_zod8.z.object({
+  /** The type's public name in the producer's export table. */
+  id: import_zod8.z.string(),
+  /** The id of the type's definition in the snapshot's type closure. */
+  type: import_zod8.z.string(),
+  /** Exposure level from the L0 entry. */
+  audience: import_zod8.z.string().default("instance")
+});
 var SurfaceContractEntrySchema = import_zod8.z.object({
   id: import_zod8.z.string(),
   name: import_zod8.z.string(),
@@ -6349,7 +6430,11 @@ var SurfaceContractEntrySchema = import_zod8.z.object({
    *  emits it as OpenAPI securitySchemes/security. */
   auth: PortalAuthSchema.optional(),
   /** The backing Portal's basePath — becomes the per-portal OpenAPI `servers` url. */
-  basePath: import_zod8.z.string().optional()
+  basePath: import_zod8.z.string().optional(),
+  /** Stereotype of the backing component; absent on snapshots written before exports carried it. */
+  componentType: import_zod8.z.string().optional(),
+  /** The L3 interface the export narrows to, when it narrows. */
+  interface: import_zod8.z.string().optional()
 });
 var SurfaceSnapshotSchema = import_zod8.z.object({
   /** Producing project/system name — the snapshot's resolution identity. */
@@ -6361,8 +6446,12 @@ var SurfaceSnapshotSchema = import_zod8.z.object({
   version: import_zod8.z.string().optional(),
   generatedAt: import_zod8.z.string(),
   interfaces: import_zod8.z.array(SurfaceContractEntrySchema).default([]),
-  /** Transitive type closure of every exported signature — self-contained. */
-  types: import_zod8.z.array(SurfaceTypeDefSchema).default([])
+  /** Transitive type closure of every exported signature and exported type — self-contained. */
+  types: import_zod8.z.array(SurfaceTypeDefSchema).default([]),
+  /** The producing project's effective id, beside the display-oriented projectName. */
+  projectId: import_zod8.z.string().optional(),
+  /** The types the producer exports by name, listed apart from the contract entries. */
+  exportedTypes: import_zod8.z.array(SurfaceTypeExportSchema).optional()
 });
 var NamedOpenApiSpecSchema = import_zod8.z.object({
   portalId: import_zod8.z.string(),
@@ -6905,6 +6994,12 @@ function ambiguityMessage(resolution, subject, ref) {
   return `${subject} cross-tree component "${ref}", which the surface snapshots of ${providers.map((p) => `"${p}"`).join(", ")} expose with different contracts \u2014 the reference matches more than one declared contract, so none of them can judge it. Name the provider it means (super::<provider>::${local}), or remove the snapshot that no longer applies.`;
 }
 
+// src/models/exports.ts
+var PUBLIC_NAME_RE = /^[a-z0-9_-]+$/;
+function exportTargetKey(e) {
+  return e.kind === "type" ? `type:${e.typeDef}` : `component:${e.component}${e.interface ? `#${e.interface}` : ""}`;
+}
+
 // src/core/narrative-labels.ts
 var SCALAR_REFS = [
   ["onTrueLabel", "onTrueStep"],
@@ -6924,7 +7019,7 @@ function resolveNarrativeLabels(methodName, steps) {
       else labels.set(s.label, s.stepNumber);
     }
   }
-  const lookup = (ref, where) => {
+  const lookup2 = (ref, where) => {
     if (typeof ref !== "string" || !ref.length) {
       errors.push(`${where} is not a label string`);
       return void 0;
@@ -6938,7 +7033,7 @@ function resolveNarrativeLabels(methodName, steps) {
   for (const s of steps) {
     for (const [labelField, stepField] of SCALAR_REFS) {
       if (s[labelField] === void 0) continue;
-      const n = lookup(s[labelField], `step ${s.stepNumber} ${labelField}`);
+      const n = lookup2(s[labelField], `step ${s.stepNumber} ${labelField}`);
       if (n !== void 0) {
         if (typeof s[stepField] === "number" && s[stepField] !== n) {
           errors.push(`step ${s.stepNumber} sets both ${stepField}=${s[stepField]} and ${labelField}="${s[labelField]}" (= step ${n}) \u2014 they disagree`);
@@ -6954,7 +7049,7 @@ function resolveNarrativeLabels(methodName, steps) {
       for (const entry of arr) {
         if (!entry || typeof entry !== "object" || entry.label === void 0) continue;
         const e = entry;
-        const n = lookup(e.label, `step ${s.stepNumber} ${key} entry`);
+        const n = lookup2(e.label, `step ${s.stepNumber} ${key} entry`);
         if (n !== void 0) {
           if (typeof e.step === "number" && e.step !== n) {
             errors.push(`step ${s.stepNumber} ${key} entry sets both step=${e.step} and label="${e.label}" (= step ${n}) \u2014 they disagree`);
@@ -7394,13 +7489,17 @@ function buildCanvasModel(issues = []) {
   const componentIds = new Set(components.map((c) => c.id));
   const publicComponents = /* @__PURE__ */ new Set();
   for (const sub of subsystems) {
-    for (const pi of sub.publicInterfaces) {
+    for (const pi of sub.publicInterfaces.filter(isOwnComponentEntry)) {
       if (pi.component) publicComponents.add(pi.component);
     }
   }
   const apiTagOf = /* @__PURE__ */ new Map();
-  for (const pi of system?.publicInterfaces ?? []) {
-    if (pi.component && pi.id) apiTagOf.set(pi.component, pi.id);
+  if (system) {
+    for (const entry of resolveProjectExports().entries) {
+      if (entry.kind === "component" && entry.component && !apiTagOf.has(entry.component)) {
+        apiTagOf.set(entry.component, entry.publicName);
+      }
+    }
   }
   const patternTypes = /* @__PURE__ */ new Set(["Repository", "FeatureComponent", "RouterComponent"]);
   const ownerOf2 = /* @__PURE__ */ new Map();
@@ -7566,7 +7665,7 @@ function buildCanvasModel(issues = []) {
   }
   const portalOf = /* @__PURE__ */ new Map();
   for (const sub of subsystems) {
-    for (const pi of sub.publicInterfaces) {
+    for (const pi of sub.publicInterfaces.filter(isOwnComponentEntry)) {
       if (pi.component && !portalOf.has(sub.id)) portalOf.set(sub.id, pi.component);
     }
   }
@@ -11837,19 +11936,25 @@ function stateIdString() {
   const s = computeStateId();
   return `${s.algorithm}:${s.digest}`;
 }
-function computeTypeClosure(entries, types) {
+function qualifiedTypeId2(spec) {
+  return spec.subsystem && !spec.id.startsWith(`${spec.subsystem}::`) ? `${spec.subsystem}::${spec.id}` : spec.id;
+}
+function computeTypeClosure(entries, types, exported = []) {
   const included = /* @__PURE__ */ new Map();
   const queue = [];
+  const include = (spec) => {
+    const key = qualifiedTypeId2(spec);
+    if (included.has(key)) return;
+    included.set(key, spec);
+    queue.push(key);
+  };
   const enqueueRef = (ref) => {
     if (BUILTIN_TYPES.has(ref.toLowerCase())) return;
     for (const spec of types) {
-      const qualifiedId = spec.subsystem && !spec.id.startsWith(`${spec.subsystem}::`) ? `${spec.subsystem}::${spec.id}` : spec.id;
-      if (matchTypeRef(ref, qualifiedId) && !included.has(spec.id)) {
-        included.set(spec.id, spec);
-        queue.push(spec.id);
-      }
+      if (matchTypeRef(ref, qualifiedTypeId2(spec))) include(spec);
     }
   };
+  for (const spec of exported) include(spec);
   for (const entry of entries) {
     for (const m of entry.methods) {
       for (const ref of methodTypeRefs(m)) enqueueRef(ref);
@@ -11861,63 +11966,87 @@ function computeTypeClosure(entries, types) {
       for (const ref of extractTypeIdentifiers(field.type)) enqueueRef(ref);
     }
   }
-  return [...included.values()].map((t) => ({
-    id: t.id,
-    name: t.name,
-    kind: t.kind,
-    fields: t.fields.map((f) => ({
-      name: f.name,
-      type: f.type,
-      ...f.description ? { description: f.description } : {},
-      ...f.optional ? { optional: true } : {}
-    }))
-  }));
+  const usedIds = /* @__PURE__ */ new Set();
+  return [...included.entries()].map(([qualified, t]) => {
+    const id = usedIds.has(t.id) ? qualified : t.id;
+    usedIds.add(id);
+    return {
+      id,
+      name: t.name,
+      kind: t.kind,
+      fields: t.fields.map((f) => ({
+        name: f.name,
+        type: f.type,
+        ...f.description ? { description: f.description } : {},
+        ...f.optional ? { optional: true } : {}
+      }))
+    };
+  });
+}
+function boundProjectId() {
+  try {
+    const config = loadProjectConfig();
+    return config ? effectiveProjectId(config) ?? void 0 : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function contractEntry(entry, comp, interfaces) {
+  const methods = interfaces.filter((i) => i.component === comp.id && (!entry.interface || i.id === entry.interface)).flatMap((i) => i.methods);
+  return {
+    id: entry.publicName,
+    name: entry.name ?? comp.name,
+    audience: entry.audience ?? "instance",
+    type: entry.type ?? "Custom",
+    component: comp.id,
+    methods,
+    ...comp.dispatch && comp.dispatch.length ? { dispatch: comp.dispatch } : {},
+    // Project the backing Portal's auth + basePath so the codec can emit
+    // OpenAPI security + per-portal servers self-contained from the snapshot.
+    ...comp.auth && comp.auth.scheme !== "none" ? { auth: comp.auth } : {},
+    ...comp.basePath ? { basePath: comp.basePath } : {},
+    details: entry.details ?? "",
+    ...entry.version ? { version: entry.version } : {},
+    ...entry.stability ? { stability: entry.stability } : {},
+    componentType: comp.componentType,
+    ...entry.interface ? { interface: entry.interface } : {}
+  };
 }
 function projectOwnSurface(maxAudience) {
   const system = loadSystemSpec();
   if (!system) {
     throw new Error("Cannot project a surface: the L0 system spec is missing.");
   }
-  const subsystems = loadSubsystemSpecs();
+  const table = resolveProjectExports();
   const components = loadComponentSpecs();
   const interfaces = loadInterfaceSpecs();
   const types = loadTypeSpecs();
   const floor = audienceRank(maxAudience);
-  const rawEntries = system.publicInterfaces ?? [];
+  const visible = table.entries.filter((e) => audienceRank(e.audience ?? "instance") >= floor);
   const entries = [];
-  for (const raw of rawEntries) {
-    const audience = raw.audience ?? "instance";
-    if (audienceRank(audience) < floor) continue;
-    if (!raw.component) continue;
-    const comp = components.find((c) => c.id === raw.component);
-    if (!comp) continue;
-    const compInterfaces = interfaces.filter((i) => i.component === comp.id && (!raw.interface || i.id === raw.interface));
-    const methods = compInterfaces.flatMap((i) => i.methods);
-    const subsystemType = subsystems.find((s) => s.id === comp.subsystem)?.publicInterfaces.find((pi) => pi.component === comp.id)?.type;
-    entries.push({
-      id: raw.id ?? raw.interface ?? comp.id,
-      name: raw.name ?? comp.name,
-      audience,
-      type: raw.type ?? subsystemType ?? "Custom",
-      component: comp.id,
-      methods,
-      ...comp.dispatch && comp.dispatch.length ? { dispatch: comp.dispatch } : {},
-      // Project the backing Portal's auth + basePath so the codec can emit
-      // OpenAPI security + per-portal servers self-contained from the snapshot.
-      ...comp.auth && comp.auth.scheme !== "none" ? { auth: comp.auth } : {},
-      ...comp.basePath ? { basePath: comp.basePath } : {},
-      details: raw.details ?? "",
-      ...raw.version ? { version: raw.version } : {},
-      ...raw.stability ? { stability: raw.stability } : {}
-    });
-  }
+  for (const entry of visible) {
+    if (entry.kind !== "component") continue;
+    const comp = components.find((c) => c.id === entry.component);
+    if (comp) entries.push(contractEntry(entry, comp, interfaces));
+  }
+  const exportedTypes = visible.filter((e) => e.kind === "type");
+  const exportedSpecs = exportedTypes.map((e) => types.find((t) => t.id === e.typeDef && (t.subsystem ?? e.source) === e.source)).filter((t) => !!t);
+  const closure = computeTypeClosure(entries, types, exportedSpecs);
+  const closureIdOf = (e) => {
+    const spec = types.find((t) => t.id === e.typeDef && (t.subsystem ?? e.source) === e.source);
+    if (!spec) return String(e.typeDef);
+    return closure.some((d) => d.id === qualifiedTypeId2(spec)) ? qualifiedTypeId2(spec) : spec.id;
+  };
+  const projectId = boundProjectId();
   return SurfaceSnapshotSchema.parse({
     projectName: system.name,
+    ...projectId ? { projectId } : {},
     origin: "generated",
     stateId: stateIdString(),
     generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
     interfaces: entries,
-    types: computeTypeClosure(entries, types)
+    types: closure,
+    ...exportedTypes.length ? { exportedTypes: exportedTypes.map((e) => ({ id: e.publicName, type: closureIdOf(e), audience: e.audience ?? "instance" })) } : {}
   });
 }
 function projectChildSurface() {
@@ -12037,7 +12166,8 @@ function listExternalInterfaces() {
       ...snapshot.stateId ? { stateId: snapshot.stateId } : {},
       ...snapshot.version ? { version: snapshot.version } : {},
       freshness,
-      interfaceIds: snapshot.interfaces.map((e) => e.id)
+      interfaceIds: snapshot.interfaces.map((e) => e.id),
+      ...snapshot.projectId ? { projectId: snapshot.projectId } : {}
     };
   });
 }
@@ -12098,7 +12228,7 @@ function defaultTargetConfig(type) {
     enabled: true
   };
 }
-var WAIRON_VERSION = "5.1.1-dev.79";
+var WAIRON_VERSION = "5.1.1-dev.80";
 var GITHUB_REPO = "SYW-Apps/Waffle-AIron";
 var ARCHITECT_AGENT_ID = "agent-architect";
 var ARCHITECT_TEMPLATE_ID = "architect";
@@ -13020,18 +13150,18 @@ function buildImportGraph(index, universe) {
   };
 }
 function buildOwnershipIndex(ctx) {
-  const ownedBy = /* @__PURE__ */ new Map();
+  const ownedBy2 = /* @__PURE__ */ new Map();
   for (const comp of ctx.components) {
     if (isRetired(comp) || !isPattern(comp)) continue;
     for (const memberId of comp.owns) {
       const member = ctx.componentMap.get(memberId);
       if (!member || isPattern(member)) continue;
-      if (!ownedBy.has(memberId)) ownedBy.set(memberId, comp.id);
+      if (!ownedBy2.has(memberId)) ownedBy2.set(memberId, comp.id);
     }
   }
   return {
-    ownedMembers: new Set(ownedBy.keys()),
-    ownerOf: (memberId) => ownedBy.get(memberId)
+    ownedMembers: new Set(ownedBy2.keys()),
+    ownerOf: (memberId) => ownedBy2.get(memberId)
   };
 }
 function buildDependencyEdges(ctx) {
@@ -13224,6 +13354,45 @@ var namespaceShadowingRule = {
   }
 };
 
+// src/core/rules/integrity/project-identity.ts
+var projectIdentityRule = {
+  name: "project-identity",
+  description: "A project is keyed on its id, so the id must be declared, well-formed and stable: a project that declares none answers to one derived from its display name until it writes one (PROJECT_ID_DEFAULTED), a project whose name yields no id or whose declared id breaks the grammar has nothing reliable to key on (PROJECT_ID_AMBIGUOUS), and an id that differs from the one the lock approved has moved under everything that keyed on it (PROJECT_ID_CHANGED).",
+  codes: [
+    { code: "PROJECT_ID_DEFAULTED", defaultSeverity: "notice", summary: "Project declares no id; it answers to one derived from its display name" },
+    { code: "PROJECT_ID_AMBIGUOUS", defaultSeverity: "warning", summary: "Project has no usable id: its name yields no slug, or its declared id breaks the grammar" },
+    { code: "PROJECT_ID_CHANGED", defaultSeverity: "error", summary: "Project id differs from the id the lock approved" }
+  ],
+  check(ctx) {
+    const identity = ctx.projectIdentity;
+    if (!identity) return;
+    const problem = (kind) => identity.problems.find((p) => p.kind === kind);
+    if (problem("defaulted")) {
+      ctx.addIssue(
+        "notice",
+        "PROJECT_ID_DEFAULTED",
+        `Project "${identity.name}" declares no id in .wai/project.yaml, so it answers to "${identity.id}", derived from its display name \u2014 renaming the project would move it. No save writes it for you; declare it with \`id: ${identity.id}\` (stage 3 requires an explicit id).`
+      );
+    }
+    const ambiguous = problem("ambiguous");
+    if (ambiguous) {
+      ctx.addIssue(
+        "warning",
+        "PROJECT_ID_AMBIGUOUS",
+        `Project "${identity.name}" has no usable id: ${ambiguous.detail}. A project id is lower-case letters, digits, "-", "_" and ".", starting and ending with a letter or a digit \u2014 declare one in .wai/project.yaml.`
+      );
+    }
+    if (problem("changed")) {
+      const now = identity.id === void 0 ? "no id at all" : `"${identity.id}"`;
+      ctx.addIssue(
+        "error",
+        "PROJECT_ID_CHANGED",
+        `Project "${identity.name}" now resolves to ${now}, but its lock approved "${identity.lockedId}" \u2014 everything keyed on the approved id no longer finds this project. Restore \`id: ${identity.lockedId}\` in .wai/project.yaml, or rename deliberately and re-lock.`
+      );
+    }
+  }
+};
+
 // src/core/rules/integrity/roundtrip-serialization.ts
 var roundtripRule = {
   name: "roundtrip-serialization",
@@ -13349,7 +13518,7 @@ var publicSurfaceBindingRule = {
   check(ctx) {
     for (const sub of ctx.subsystems) {
       const isDraftCtx = isDraftSubsystem(sub);
-      for (const pi of sub.publicInterfaces) {
+      for (const pi of sub.publicInterfaces.filter(isOwnComponentEntry)) {
         if (!pi.component) {
           ctx.addIssue("error", "PUBLIC_INTERFACE_UNBOUND", `Subsystem "${sub.id}" declares a ${pi.type} public interface with no backing component. Bind it to the component that realizes it (publicInterfaces[].component).`, sub.id, isDraftCtx);
           continue;
@@ -13436,13 +13605,15 @@ var publicSurfaceDeclaredTypeRule = {
   check(ctx) {
     for (const sub of ctx.subsystems) {
       const isDraftCtx = isDraftSubsystem(sub);
-      for (const pi of sub.publicInterfaces) {
+      for (const pi of sub.publicInterfaces.filter(isOwnComponentEntry)) {
         const backing = pi.component ? ctx.componentMap.get(pi.component) : void 0;
         if (!backing) continue;
-        if (!pubTypeMatches(pi.type, backing.componentType, backing.portalType)) {
-          ctx.addIssue("error", "PUBLIC_INTERFACE_TYPE_MISMATCH", `Subsystem "${sub.id}" declares a ${pi.type} public interface backed by "${pi.component}" (${backing.componentType}${backing.portalType ? `/${backing.portalType}` : ""}), which cannot realize ${pi.type}. Expected ${expectedFor(pi.type)}.`, sub.id, isDraftCtx);
+        const piType = pi.type ?? "Custom";
+        const piDetails = pi.details ?? "";
+        if (!pubTypeMatches(piType, backing.componentType, backing.portalType)) {
+          ctx.addIssue("error", "PUBLIC_INTERFACE_TYPE_MISMATCH", `Subsystem "${sub.id}" declares a ${pi.type} public interface backed by "${pi.component}" (${backing.componentType}${backing.portalType ? `/${backing.portalType}` : ""}), which cannot realize ${pi.type}. Expected ${expectedFor(piType)}.`, sub.id, isDraftCtx);
         }
-        if (pi.type === "Custom" && EVENT_VOCAB.test(pi.details)) {
+        if (piType === "Custom" && EVENT_VOCAB.test(piDetails)) {
           const eventCapable = backing.componentType === "Observer" || backing.componentType === "Portal" && backing.portalType === "MessageBus";
           if (!eventCapable) {
             ctx.addIssue("warning", "PUBLIC_INTERFACE_EVENT_MISTYPED", `Subsystem "${sub.id}" declares a Custom public interface whose description implies an event/async boundary ("${pi.details}"), but it is backed by "${pi.component}" (${backing.componentType}${backing.portalType ? `/${backing.portalType}` : ""}), which cannot realize eventing. If this is genuinely event-driven, type it MessageBus and back it with an Observer or a Portal(MessageBus); otherwise reword the description to match the synchronous contract.`, sub.id, isDraftCtx);
@@ -13463,7 +13634,7 @@ var publicSurfaceBoundContractRule = {
   check(ctx) {
     for (const sub of ctx.subsystems) {
       const isDraftCtx = isDraftSubsystem(sub);
-      for (const pi of sub.publicInterfaces) {
+      for (const pi of sub.publicInterfaces.filter(isOwnComponentEntry)) {
         if (!pi.interface) continue;
         if (!pi.component || !ctx.componentMap.has(pi.component)) continue;
         const intf = ctx.interfaceMap.get(pi.interface);
@@ -13477,6 +13648,47 @@ var publicSurfaceBoundContractRule = {
   }
 };
 
+// src/core/rules/integrity/export-tables.ts
+var exportTablesRule = {
+  name: "export-tables",
+  description: "Every level's export table must resolve the way a module resolver resolves `export \u2026 from`: one public name binds one target (EXPORT_ID_DUPLICATE when two wildcards \u2014 or two explicit entries \u2014 bind a name to different targets; the name is left out), no chain leads back to itself (EXPORT_CYCLE \u2014 an error for a named chain that never reaches a component or type, a warning for a wildcard cycle, which resolves to its union), every entry names a source and an item that exist, that the source exports and, for an own type, that the level owns, under a public name of [a-z0-9-_]+ (EXPORT_INVALID), and every re-exported component can serve a boundary caller \u2014 a Portal, a gateway being a Portal variant, or an Observer for events (EXPORT_UNCONSUMABLE, at L0 and for L1 re-exports). The rule judges the facts the export resolver gathered and resolves nothing itself.",
+  codes: [
+    { code: "EXPORT_ID_DUPLICATE", defaultSeverity: "error", summary: "One public name bound to different targets by two wildcard re-exports or two explicit entries" },
+    { code: "EXPORT_CYCLE", defaultSeverity: "error", summary: "A re-export chain leads back to itself (a warning for a wildcard cycle, which resolves to its union)" },
+    { code: "EXPORT_INVALID", defaultSeverity: "notice", summary: "An export entry names a missing source or item, an item its source does not export or its level does not own, or a malformed public name" },
+    { code: "EXPORT_UNCONSUMABLE", defaultSeverity: "notice", summary: "An exported component no boundary caller may reach: neither a Portal nor an Observer" }
+  ],
+  check(ctx) {
+    const tables = ctx.exportTables;
+    if (!tables) return;
+    for (const table of tables) {
+      const sub = table.level === "subsystem" ? ctx.subsystems.find((s) => s.id === table.owner) : void 0;
+      const draft = sub ? isDraftSubsystem(sub) : false;
+      const where = table.level === "subsystem" ? `Subsystem "${table.owner}"` : `The project's L0 export table`;
+      for (const problem of table.problems) {
+        const name = problem.publicName ? `"${problem.publicName}"` : "an entry";
+        switch (problem.kind) {
+          case "duplicate":
+            ctx.addIssue("error", "EXPORT_ID_DUPLICATE", `${where} binds ${name} to more than one target (${(problem.targets ?? []).join(", ")}), so the name is left out of the table. Narrow one of the wildcards, or add an explicit entry that picks the target.`, table.owner, draft);
+            break;
+          case "named-cycle":
+            ctx.addIssue("error", "EXPORT_CYCLE", `${where} ${problem.detail}. Export the item from the level that owns it.`, table.owner, draft);
+            break;
+          case "wildcard-cycle":
+            ctx.addIssue("warning", "EXPORT_CYCLE", `${where}: ${problem.detail}. Re-export in one direction only.`, table.owner, draft);
+            break;
+          case "invalid":
+            ctx.addIssue("notice", "EXPORT_INVALID", `${where} ${problem.detail}.`, table.owner, draft);
+            break;
+          case "unconsumable":
+            ctx.addIssue("notice", "EXPORT_UNCONSUMABLE", `${where}: ${problem.detail}.`, table.owner, draft);
+            break;
+        }
+      }
+    }
+  }
+};
+
 // src/core/rules/integrity/lint-allows.ts
 var lintAllowsRule = {
   name: "lint-allows",
@@ -14868,7 +15080,7 @@ var subsystemBoundaryDepsRule = {
   }
 };
 function restrictedConsumers(ctx, subsystemId, componentId) {
-  const entries = (ctx.subsystems.find((s) => s.id === subsystemId)?.publicInterfaces ?? []).filter((pi) => pi.component === componentId);
+  const entries = (ctx.subsystems.find((s) => s.id === subsystemId)?.publicInterfaces ?? []).filter((pi) => isOwnComponentEntry(pi) && pi.component === componentId);
   if (entries.length === 0 || entries.some((pi) => pi.consumers === void 0)) return null;
   return [...new Set(entries.flatMap((pi) => pi.consumers ?? []))];
 }
@@ -14922,14 +15134,35 @@ var logicDependencyClassRule = {
 };
 
 // src/core/rules/doctrine/data-block-dependencies.ts
+function indexReaches(ctx, from, target, seen = /* @__PURE__ */ new Set()) {
+  for (const dep of from.dependsOn) {
+    if (dep === target) return true;
+    const next = ctx.componentMap.get(dep);
+    if (!next || next.componentType !== "Index" || seen.has(dep)) continue;
+    seen.add(dep);
+    if (indexReaches(ctx, next, target, seen)) return true;
+  }
+  return false;
+}
+function derivedIndexBreach(ctx, from, to) {
+  const ownership = ctx.ownershipIndex();
+  const owner = ownership.ownerOf(from.id);
+  if (!owner || owner !== ownership.ownerOf(to.id)) {
+    return "An Index may project another Index only when one Repository owns both";
+  }
+  if (indexReaches(ctx, to, from.id)) {
+    return `"${to.id}" depends back on "${from.id}" through Index edges \u2014 derived Indexes never form a cycle`;
+  }
+  return void 0;
+}
 var dataBlockDepsRule = {
   name: "data-block-dependencies",
-  description: "Keeps the data layer facing down. A Store may depend only on another Store, a backend Adapter or pure logic \u2014 Registries and Indexes depend on the Store, never the reverse. A Registry is the write path to its Store and may depend on that Store, a backend Adapter, or the pure logic that validates the write. An Index is a read projection and a Query a computed read, each over its Store through a backend Adapter where one serves it. An Adapter is a sink toward the system: it may use pure logic, but never a Store or any other Orchestrator.",
+  description: "Keeps the data layer facing down. A Store may depend only on another Store, a backend Adapter or pure logic \u2014 Registries and Indexes depend on the Store, never the reverse. A Registry is the write path to its Store and may depend on that Store, a backend Adapter, or the pure logic that validates the write. An Index is a read projection and a Query a computed read, each over its Store through a backend Adapter where one serves it; as an exceptional case an Index may project another Index of the same Repository, never in a cycle. An Adapter is a sink toward the system: it may use pure logic, but never a Store or any other Orchestrator.",
   codes: [
     { code: "ARCHITECTURE_VIOLATION_STORE_DEP", defaultSeverity: "error", summary: "Store depending on anything but another Store, a backend Adapter or pure logic" },
     { code: "ARCHITECTURE_VIOLATION_REGISTRY_DEP", defaultSeverity: "warning", summary: "Registry depending on anything but its Store, a backend Adapter or pure logic (warning while new; aligned to the standard \xA77 validate\u2192write path)" },
     { code: "ARCHITECTURE_VIOLATION_ADAPTER_DEP", defaultSeverity: "error", summary: "Adapter depending on a Store or on an Orchestrator that is not pure" },
-    { code: "ARCHITECTURE_VIOLATION_INDEX_DEP", defaultSeverity: "error", summary: "Index depending on anything but its Store, an Adapter or pure logic" },
+    { code: "ARCHITECTURE_VIOLATION_INDEX_DEP", defaultSeverity: "error", summary: "Index depending on anything but its Store, an Adapter, pure logic or another Index of its own Repository (never in a cycle)" },
     { code: "ARCHITECTURE_VIOLATION_QUERY_DEP", defaultSeverity: "error", summary: "Query depending on anything but its Store, a backend Adapter or pure logic" }
   ],
   check(ctx) {
@@ -14966,11 +15199,13 @@ var dataBlockDepsRule = {
           edge.draftContext
         );
       }
-      if (comp.componentType === "Index" && ownStoreOnly) {
+      const indexBreach = comp.componentType === "Index" && depComp.componentType === "Index" ? derivedIndexBreach(ctx, comp, depComp) : void 0;
+      const derivedIndexOk = comp.componentType === "Index" && depComp.componentType === "Index" && !indexBreach;
+      if (comp.componentType === "Index" && ownStoreOnly && !derivedIndexOk) {
         ctx.addIssue(
           "error",
           "ARCHITECTURE_VIOLATION_INDEX_DEP",
-          `Architectural violation: Index component "${comp.id}" cannot depend on "${depComp.componentType}" component "${depComp.id}". An Index is a read projection and may depend only on its Store, a backend Adapter or pure logic.`,
+          `Architectural violation: Index component "${comp.id}" cannot depend on "${depComp.componentType}" component "${depComp.id}". An Index is a read projection and may depend only on its Store, a backend Adapter or pure logic \u2014 or, as an exceptional case, on another Index of the same Repository, never in a cycle.${indexBreach ? ` ${indexBreach}.` : ""}`,
           comp.id,
           edge.draftContext
         );
@@ -19355,6 +19590,9 @@ var SDD_RULES = [
   // that would anchor a bare reference to the root instead.
   reservedIdSegmentsRule,
   namespaceShadowingRule,
+  // The project's own id, beside the spec ids: declared, well-formed, and the
+  // one its lock approved.
+  projectIdentityRule,
   roundtripRule,
   // The type vocabulary in three questions: what a type declares about
   // itself, then the identifiers its fields name, then the ones its
@@ -19446,6 +19684,8 @@ var SDD_RULES = [
   publicSurfaceConsumersRule,
   publicSurfaceDeclaredTypeRule,
   publicSurfaceBoundContractRule,
+  // The export tables the resolver settled: what the published names bind.
+  exportTablesRule,
   cyclesRule,
   // Semantic-edge family: dispatch/lifecycle validity BEFORE reachability so a
   // reader sees the broken edge finding next to the unused-detection fallout
@@ -20684,7 +20924,7 @@ function buildRuleContext(opts) {
   for (const sub of subsystems) {
     publicSet.set(
       sub.id,
-      new Set(sub.publicInterfaces.map((pi) => pi.component).filter((c) => !!c))
+      new Set(sub.publicInterfaces.filter(isOwnComponentEntry).map((pi) => pi.component).filter((c) => !!c))
     );
   }
   const surfaceSnapshots = opts.surfaceSnapshots ?? [];
@@ -20788,7 +21028,7 @@ function buildRuleContext(opts) {
       const candidates = [];
       for (const snapshot of pool) {
         if (provider !== void 0 && !isProvidedBy(snapshot, provider)) continue;
-        const entry = snapshot.interfaces.find((e) => e.component === local || e.id === local);
+        const entry = snapshot.interfaces.find((e) => e.id === local) ?? snapshot.interfaces.find((e) => e.component === local && (e.componentType === void 0 || e.id === e.component || e.id === e.interface));
         if (entry) candidates.push({ snapshot, entry });
       }
       if (candidates.length === 0) continue;
@@ -21027,6 +21267,8 @@ function buildRuleContext(opts) {
     ext: { profiles: extensions.profiles, languages: extensions.languages, patterns: extensions.patterns, guarantees: extensions.guarantees, assertions: extensions.assertions, packSelections: opts.packSelections ?? [], selectionFailures: extensions.selectionFailures ?? [] },
     variants: opts.variants ?? [],
     surfaceSnapshots,
+    ...opts.projectIdentity ? { projectIdentity: opts.projectIdentity } : {},
+    ...opts.exportTables ? { exportTables: opts.exportTables } : {},
     mountSurfaceSnapshots,
     codeModel: opts.codeModel ?? emptyCodeModel(),
     roundTripIssues: opts.roundTripIssues,
@@ -21098,6 +21340,17 @@ function projectPackSelections() {
     return [];
   }
 }
+function boundProjectIdentity() {
+  let config;
+  try {
+    config = loadProjectConfig();
+  } catch {
+    return void 0;
+  }
+  if (!config) return void 0;
+  const lockedProjectId = readLockRecord()?.projectId;
+  return projectIdentity(config, lockedProjectId);
+}
 function findTestsReferencing2(methods, projectRoot, testRoots = []) {
   return findTestsReferencing(methods, projectRoot, testRoots);
 }
@@ -21300,8 +21553,17 @@ function validateSddTree(rulesOrOptions, projectType = "backend") {
       scopeSubsystem,
       extensions,
       variants: loadProjectVariants(),
+      // Every subsystem's resolved export table, then the project's: the
+      // export-tables rule judges the problems the resolver met.
+      exportTables: [
+        ...subsystems.map((s) => resolveSubsystemExports(s.id)),
+        resolveProjectExports()
+      ],
       // By-name selections only: a legacy path ref pins nothing to check.
       packSelections: projectPackSelections(),
+      // The run that IS the parent's verdict on a chained child judges the
+      // child's specs, not the parent's identity, so it carries none.
+      projectIdentity: crossTree === "off" ? void 0 : boundProjectIdentity(),
       surfaceSnapshots,
       mountSurfaceSnapshots,
       codeModel,
@@ -21555,7 +21817,7 @@ function loadSpecGraph() {
   const implementations = loadImplementationSpecs();
   const publicComponents = /* @__PURE__ */ new Set();
   for (const sub of subsystems) {
-    for (const pi of sub.publicInterfaces) {
+    for (const pi of sub.publicInterfaces.filter(isOwnComponentEntry)) {
       if (pi.component) publicComponents.add(pi.component);
     }
   }
@@ -21964,6 +22226,350 @@ function diagramSetIndex(files, systemName) {
   return lines.join("\n");
 }
 
+// src/core/exports.ts
+var CONSUMABLE = /* @__PURE__ */ new Set(["Portal", "Observer"]);
+function localName2(id) {
+  return id.split("::").pop() ?? id;
+}
+function ownedBy(subsystemId, declaringSubsystem) {
+  return declaringSubsystem !== void 0 && (declaringSubsystem === subsystemId || declaringSubsystem.startsWith(`${subsystemId}::`));
+}
+function worldOf(subsystems, components, interfaces, types) {
+  return {
+    subsystems: new Map(subsystems.map((s) => [s.id, s])),
+    components: new Map(components.map((c) => [c.id, c])),
+    interfaces: new Map(interfaces.map((i) => [i.id, i])),
+    types: types.reduce((m, t) => m.set(t.id, [...m.get(t.id) ?? [], t]), /* @__PURE__ */ new Map())
+  };
+}
+function lookup(map, ref, namespace) {
+  if (!ref) return void 0;
+  return map.get(ref) ?? (namespace ? map.get(`${namespace}::${ref}`) : void 0);
+}
+function lookupType(world, ref, subsystemId) {
+  const candidates = lookup(world.types, ref, subsystemId);
+  return candidates?.find((t) => ownedBy(subsystemId, t.subsystem)) ?? candidates?.[0];
+}
+function checkPublicName(name, owner, problems) {
+  if (!PUBLIC_NAME_RE.test(name)) {
+    problems.push({
+      kind: "invalid",
+      owner,
+      publicName: name,
+      detail: `public name "${name}" breaks [a-z0-9-_]+ \u2014 rename it with \`as\``
+    });
+  }
+}
+function checkConsumable(entry, owner, problems) {
+  if (entry.kind === "component" && entry.componentType && !CONSUMABLE.has(entry.componentType)) {
+    problems.push({
+      kind: "unconsumable",
+      owner,
+      publicName: entry.publicName,
+      targets: [entry.component],
+      detail: `"${entry.publicName}" exports ${entry.componentType} "${entry.component}", which no caller across the boundary may reach \u2014 only a Portal (a gateway is a Portal variant) or an Observer can serve one`
+    });
+  }
+}
+function findInSource(world, source, table, request) {
+  if (request.typeDef) {
+    const type = lookupType(world, request.typeDef, source.id);
+    if (!type) return {};
+    const item2 = { publicName: localName2(type.id), kind: "type", source: type.subsystem ?? source.id, typeDef: type.id, via: [] };
+    return { item: item2, found: table.entries.find((e) => e.kind === "type" && e.typeDef === type.id && e.source === item2.source) };
+  }
+  const intf = lookup(world.interfaces, request.interface, source.id);
+  const comp = lookup(world.components, request.component ?? intf?.component, source.id);
+  if (!comp) return {};
+  const narrowed = intf?.id ?? request.interface;
+  const item = {
+    publicName: localName2(narrowed ?? comp.id),
+    kind: "component",
+    source: comp.subsystem,
+    component: comp.id,
+    ...narrowed ? { interface: narrowed } : {},
+    componentType: comp.componentType,
+    via: []
+  };
+  const exported = table.entries.filter((e) => e.kind === "component" && e.component === comp.id);
+  const found = narrowed ? exported.find((e) => e.interface === narrowed) ?? exported.find((e) => e.interface === void 0) : exported.find((e) => e.interface === void 0) ?? exported[0];
+  return { item, found: found && narrowed ? { ...found, interface: narrowed } : found };
+}
+function bindNamed(world, owner, source, sourceTable, request, publicName, inCycle, problems) {
+  const { found, item } = findInSource(world, source, sourceTable, request);
+  const what = request.typeDef ? `type "${request.typeDef}"` : `component "${request.component}"${request.interface ? ` (interface "${request.interface}")` : ""}`;
+  if (!item) {
+    problems.push({ kind: "invalid", owner, detail: `re-exports ${what} from "${source.id}", which has no such item` });
+    return void 0;
+  }
+  const name = publicName(item);
+  if (found) return { ...found, publicName: name, via: [source.id, ...found.via] };
+  if (inCycle) {
+    problems.push({ kind: "named-cycle", owner, publicName: name, targets: [owner, source.id], detail: `re-exports ${what} from "${source.id}", but the chain leads back to "${owner}" without reaching the item` });
+    return void 0;
+  }
+  const declaring = item.source;
+  if (!ownedBy(source.id, declaring)) {
+    problems.push({ kind: "invalid", owner, publicName: name, detail: `re-exports ${what} from "${source.id}", which neither exports nor owns it` });
+    return void 0;
+  }
+  problems.push({ kind: "invalid", owner, publicName: name, detail: `re-exports ${what} from "${source.id}", which does not export it \u2014 publish it there first` });
+  return { ...item, publicName: name, via: [source.id] };
+}
+function bindOwn(world, sub, pi, problems) {
+  if (pi.typeDef) {
+    const type = lookupType(world, pi.typeDef, sub.id);
+    if (!type || !ownedBy(sub.id, type.subsystem)) {
+      problems.push({ kind: "invalid", owner: sub.id, detail: `exports type "${pi.typeDef}" as its own, but ${type ? `it belongs to "${type.subsystem ?? "the system"}"` : "no such type exists"}` });
+      return void 0;
+    }
+    const name2 = pi.as ?? localName2(type.id);
+    checkPublicName(name2, sub.id, problems);
+    return { publicName: name2, kind: "type", source: type.subsystem ?? sub.id, typeDef: type.id, via: [] };
+  }
+  const comp = lookup(world.components, pi.component, sub.id);
+  if (!comp || !ownedBy(sub.id, comp.subsystem)) return void 0;
+  const intf = lookup(world.interfaces, pi.interface, sub.id);
+  const narrowed = intf?.id ?? pi.interface;
+  const name = pi.as ?? localName2(narrowed ?? comp.id);
+  checkPublicName(name, sub.id, problems);
+  return {
+    publicName: name,
+    kind: "component",
+    source: sub.id,
+    component: comp.id,
+    ...narrowed ? { interface: narrowed } : {},
+    componentType: comp.componentType,
+    ...pi.type ? { type: pi.type } : {},
+    ...pi.details !== void 0 ? { details: pi.details } : {},
+    via: []
+  };
+}
+function subsystemCandidates(world, sub, tables, group, problems) {
+  const out = [];
+  sub.publicInterfaces.forEach((pi, index) => {
+    if (pi.from === void 0) {
+      const own = bindOwn(world, sub, pi, problems);
+      if (own) out.push({ entry: own, explicit: true, from: index });
+      return;
+    }
+    const source = world.subsystems.get(pi.from);
+    if (!source || source.id === sub.id) {
+      problems.push({ kind: "invalid", owner: sub.id, detail: source ? `re-exports from itself` : `re-exports from "${pi.from}", which is not a subsystem of this project` });
+      return;
+    }
+    const sourceTable = tables.get(source.id) ?? emptyTable(source.id, "subsystem");
+    if (pi.component !== void 0 || pi.typeDef !== void 0 || pi.interface !== void 0) {
+      const bound2 = bindNamed(
+        world,
+        sub.id,
+        source,
+        sourceTable,
+        { component: pi.component, interface: pi.interface, typeDef: pi.typeDef },
+        (item) => pi.as ?? localName2(pi.interface ?? item.typeDef ?? item.component ?? ""),
+        group.has(source.id),
+        problems
+      );
+      if (!bound2) return;
+      checkPublicName(bound2.publicName, sub.id, problems);
+      const entry = { ...bound2, ...pi.type ? { type: pi.type } : {}, ...pi.details !== void 0 ? { details: pi.details } : {} };
+      checkConsumable(entry, sub.id, problems);
+      out.push({ entry, explicit: true, from: index });
+      return;
+    }
+    for (const e of sourceTable.entries) {
+      const entry = { ...e, via: [source.id, ...e.via] };
+      checkConsumable(entry, sub.id, problems);
+      out.push({ entry, explicit: false, from: index });
+    }
+  });
+  return out;
+}
+function emptyTable(owner, level) {
+  return { owner, level, entries: [], problems: [] };
+}
+function settle(owner, level, candidates, problems) {
+  const byName = /* @__PURE__ */ new Map();
+  for (const c of candidates) {
+    const list = byName.get(c.entry.publicName) ?? [];
+    list.push(c);
+    byName.set(c.entry.publicName, list);
+  }
+  const entries = [];
+  for (const [name, list] of byName) {
+    const explicit = list.filter((c) => c.explicit);
+    const pool = explicit.length ? explicit : list;
+    const targets = [...new Set(pool.map((c) => exportTargetKey(c.entry)))];
+    if (targets.length === 1) {
+      entries.push(pool[0].entry);
+      continue;
+    }
+    problems.push({
+      kind: "duplicate",
+      owner,
+      publicName: name,
+      targets,
+      detail: `"${name}" is bound to ${targets.length} different targets (${targets.join(", ")}) by ${explicit.length ? "explicit entries" : "wildcard re-exports"}; it is left out of the table`
+    });
+  }
+  return { owner, level, entries, problems };
+}
+function groupsInDependencyOrder(world) {
+  const edges = /* @__PURE__ */ new Map();
+  for (const sub of world.subsystems.values()) {
+    edges.set(sub.id, sub.publicInterfaces.map((pi) => pi.from).filter((f) => f !== void 0 && f !== sub.id && world.subsystems.has(f)));
+  }
+  const index = /* @__PURE__ */ new Map();
+  const low = /* @__PURE__ */ new Map();
+  const stack = [];
+  const onStack = /* @__PURE__ */ new Set();
+  const groups = [];
+  let next = 0;
+  const visit = (v) => {
+    index.set(v, next);
+    low.set(v, next);
+    next++;
+    stack.push(v);
+    onStack.add(v);
+    for (const w of edges.get(v) ?? []) {
+      if (!index.has(w)) {
+        visit(w);
+        low.set(v, Math.min(low.get(v), low.get(w)));
+      } else if (onStack.has(w)) low.set(v, Math.min(low.get(v), index.get(w)));
+    }
+    if (low.get(v) === index.get(v)) {
+      const group = [];
+      let w;
+      do {
+        w = stack.pop();
+        onStack.delete(w);
+        group.push(w);
+      } while (w !== v);
+      groups.push(group.sort());
+    }
+  };
+  for (const id of [...world.subsystems.keys()].sort()) if (!index.has(id)) visit(id);
+  return groups;
+}
+function fingerprint(table) {
+  return table.entries.map((e) => `${e.publicName}=${exportTargetKey(e)}`).sort().join("|");
+}
+function resolveSubsystemTables(subsystems, components, interfaces, types) {
+  const world = worldOf(subsystems, components, interfaces, types);
+  const tables = /* @__PURE__ */ new Map();
+  for (const group of groupsInDependencyOrder(world)) {
+    const members = new Set(group);
+    const cyclic = group.length > 1;
+    for (let pass = 0, changed = true; changed && pass <= (cyclic ? group.length * 4 + 4 : 0); pass++) {
+      changed = false;
+      for (const id of group) {
+        const problems = [];
+        const table = settle(id, "subsystem", subsystemCandidates(world, world.subsystems.get(id), tables, cyclic ? members : /* @__PURE__ */ new Set(), problems), problems);
+        const before = tables.get(id);
+        if (!before || fingerprint(before) !== fingerprint(table)) changed = true;
+        tables.set(id, table);
+      }
+    }
+    const wildcardLoop = cyclic && group.some((id) => world.subsystems.get(id).publicInterfaces.some((pi) => pi.from !== void 0 && pi.component === void 0 && pi.typeDef === void 0 && pi.interface === void 0 && members.has(pi.from)));
+    if (wildcardLoop) {
+      tables.get(group[0]).problems.push({
+        kind: "wildcard-cycle",
+        owner: group[0],
+        targets: group,
+        detail: `subsystems ${group.map((g) => `"${g}"`).join(", ")} re-export each other through wildcards; their tables resolve to the union, but they form one circular module surface`
+      });
+    }
+  }
+  return tables;
+}
+function sourceOf(world, e) {
+  if (e.from ?? e.subsystem) return e.from ?? e.subsystem;
+  if (e.component) return world.components.get(e.component)?.subsystem;
+  if (e.interface) {
+    const intf = world.interfaces.get(e.interface);
+    return intf ? world.components.get(intf.component)?.subsystem : void 0;
+  }
+  if (e.typeDef) return world.types.get(e.typeDef)?.[0]?.subsystem;
+  return void 0;
+}
+function withEntryMetadata(entry, e) {
+  return {
+    ...entry,
+    audience: e.audience ?? "instance",
+    ...e.name ? { name: e.name } : {},
+    ...e.type ? { type: e.type } : {},
+    ...e.details !== void 0 ? { details: e.details } : {},
+    ...e.authPolicy ? { authPolicy: e.authPolicy } : {},
+    ...e.version ? { version: e.version } : {},
+    ...e.stability ? { stability: e.stability } : {}
+  };
+}
+function resolveProjectTable(system, subsystems, components, interfaces, types, subsystemTables) {
+  const world = worldOf(subsystems, components, interfaces, types);
+  const owner = system.name;
+  const problems = [];
+  const candidates = [];
+  (system.publicInterfaces ?? []).forEach((e, index) => {
+    const sourceId = sourceOf(world, e);
+    const source = sourceId ? world.subsystems.get(sourceId) : void 0;
+    if (!source) {
+      const label = e.as ?? e.id ?? e.interface ?? e.component ?? e.typeDef ?? `#${index + 1}`;
+      problems.push({ kind: "invalid", owner, publicName: label, detail: sourceId ? `"${label}" re-exports from "${sourceId}", which is not a subsystem of this project` : `"${label}" names no source subsystem and no item whose owner could supply one` });
+      return;
+    }
+    const sourceTable = subsystemTables.get(source.id) ?? emptyTable(source.id, "subsystem");
+    if (e.component !== void 0 || e.typeDef !== void 0 || e.interface !== void 0) {
+      const bound2 = bindNamed(
+        world,
+        owner,
+        source,
+        sourceTable,
+        { component: e.component, interface: e.interface, typeDef: e.typeDef },
+        () => e.as ?? e.id ?? e.interface ?? e.component ?? e.typeDef,
+        false,
+        problems
+      );
+      if (!bound2) return;
+      checkPublicName(bound2.publicName, owner, problems);
+      const entry = withEntryMetadata(bound2, e);
+      checkConsumable(entry, owner, problems);
+      candidates.push({ entry, explicit: true, from: index });
+      return;
+    }
+    for (const found of sourceTable.entries) {
+      const entry = withEntryMetadata({ ...found, via: [source.id, ...found.via] }, e);
+      checkConsumable(entry, owner, problems);
+      candidates.push({ entry, explicit: false, from: index });
+    }
+  });
+  return settle(owner, "project", candidates, problems);
+}
+var subsystemMemo = /* @__PURE__ */ new WeakMap();
+var projectMemo = /* @__PURE__ */ new WeakMap();
+function scanTables(subsystems) {
+  const memo = subsystemMemo.get(subsystems);
+  if (memo) return memo;
+  const tables = resolveSubsystemTables(subsystems, loadComponentSpecs(), loadInterfaceSpecs(), loadTypeSpecs());
+  subsystemMemo.set(subsystems, tables);
+  return tables;
+}
+function resolveSubsystemExportTable(subsystemId) {
+  const tables = scanTables(loadSubsystemSpecs());
+  return tables.get(subsystemId) ?? emptyTable(subsystemId, "subsystem");
+}
+function resolveProjectExportTable() {
+  const system = loadSystemSpec();
+  if (!system) return emptyTable("", "project");
+  const subsystems = loadSubsystemSpecs();
+  const key = JSON.stringify([system.name, system.publicInterfaces ?? []]);
+  const memo = projectMemo.get(subsystems);
+  if (memo && memo.key === key) return memo.table;
+  const subsystemTables = new Map(subsystems.map((sub) => [sub.id, resolveSubsystemExportTable(sub.id)]));
+  const table = resolveProjectTable(system, subsystems, loadComponentSpecs(), loadInterfaceSpecs(), loadTypeSpecs(), subsystemTables);
+  projectMemo.set(subsystems, { key, table });
+  return table;
+}
+
 // src/core/specs.ts
 function emptyIndex() {
   return {
@@ -22212,13 +22818,18 @@ function mergeMountRealizations(subs) {
 function stripNamespaceFromSubsystem(spec, prefix) {
   const memberPrefix = spec.projectPath ? spec.id : prefix;
   const relMember = (id) => id.includes("::") ? relativizeId(id, memberPrefix) : id;
+  const relPeer = (id) => id.includes("::") ? relativizeId(id, prefix) : id;
   return {
     ...spec,
     id: relativizeId(spec.id, prefix),
     publicInterfaces: spec.publicInterfaces.map((pi) => ({
       ...pi,
-      component: pi.component ? relMember(pi.component) : void 0,
-      interface: pi.interface ? relMember(pi.interface) : void 0,
+      // A re-export names a peer's item, written relative to the namespace the
+      // subsystem is declared in (the loader's inverse), not its members'.
+      component: pi.component ? pi.from ? relPeer(pi.component) : relMember(pi.component) : void 0,
+      interface: pi.interface ? pi.from ? relPeer(pi.interface) : relMember(pi.interface) : void 0,
+      ...pi.typeDef ? { typeDef: pi.from ? relPeer(pi.typeDef) : relMember(pi.typeDef) } : {},
+      ...pi.from ? { from: relPeer(pi.from) } : {},
       // consumers name SUBSYSTEMS — peers of this one, so they are relative to
       // the namespace the subsystem itself is declared in, never its members'.
       ...pi.consumers ? { consumers: pi.consumers.map((c) => c.includes("::") ? relativizeId(c, prefix) : c) } : {}
@@ -22495,6 +23106,14 @@ function identityKeyOf(field, item) {
 }
 function publicInterfaceKey(o) {
   const str = (v) => typeof v === "string" && v.length > 0 ? v : null;
+  const from = str(o.from);
+  const typeDef = str(o.typeDef);
+  if (from || typeDef) {
+    const item = typeDef ? `type ${typeDef}` : str(o.component) ?? "*";
+    const narrowed = str(o.interface) ? `.${String(o.interface)}` : "";
+    const renamed = str(o.as) ? ` as ${String(o.as)}` : "";
+    return `${from ? `${from}:` : ""}${item}${narrowed}${renamed}`;
+  }
   const component = str(o.component);
   if (component) return str(o.interface) ? `${component}.${String(o.interface)}` : component;
   if (typeof o.type === "string" && typeof o.details === "string") return `${o.type} ${o.details}`;
@@ -22711,8 +23330,9 @@ function identityFieldsOf(field) {
     case "dispatch":
       return ["capability"];
     // Bound: component + interface; not yet bound: type + details.
+    // Re-exports and type exports: from + item + interface + as.
     case "publicInterfaces":
-      return ["component", "interface", "type", "details"];
+      return ["component", "interface", "type", "details", "from", "typeDef", "as"];
     case "lifecycle":
       return ["phase", "component", "method"];
     case "emits":
@@ -22984,14 +23604,19 @@ var SpecWorkspace = class {
       return {
         ...sub,
         id: qualifiedSubId,
-        publicInterfaces: sub.publicInterfaces.map((p) => ({
-          ...p,
-          component: p.component ? qualifyId(p.component, componentPrefix, this.rootSubsystems) : void 0,
-          interface: p.interface ? qualifyId(p.interface, componentPrefix, this.rootSubsystems) : void 0,
-          // Each consumer is a subsystem reference: qualified into the namespace
-          // this subsystem is declared in, like a component's `subsystem` field.
-          ...p.consumers ? { consumers: p.consumers.map((c) => qualifySubsystemRef(c, namespacePrefix, this.rootSubsystems)) } : {}
-        })),
+        publicInterfaces: sub.publicInterfaces.map((p) => {
+          const itemPrefix = p.from ? namespacePrefix : componentPrefix;
+          return {
+            ...p,
+            component: p.component ? qualifyId(p.component, itemPrefix, this.rootSubsystems) : void 0,
+            interface: p.interface ? qualifyId(p.interface, itemPrefix, this.rootSubsystems) : void 0,
+            ...p.typeDef ? { typeDef: qualifyId(p.typeDef, itemPrefix, this.rootSubsystems) } : {},
+            ...p.from ? { from: qualifySubsystemRef(p.from, namespacePrefix, this.rootSubsystems) } : {},
+            // Each consumer is a subsystem reference: qualified into the namespace
+            // this subsystem is declared in, like a component's `subsystem` field.
+            ...p.consumers ? { consumers: p.consumers.map((c) => qualifySubsystemRef(c, namespacePrefix, this.rootSubsystems)) } : {}
+          };
+        }),
         lifecycle: sub.lifecycle?.map((le) => ({
           ...le,
           component: qualifyId(le.component, componentPrefix, this.rootSubsystems)
@@ -24603,8 +25228,12 @@ var SpecWorkspace = class {
           if (Array.isArray(out.publicInterfaces)) {
             out.publicInterfaces = out.publicInterfaces.map((pi) => ({
               ...pi,
-              ...typeof pi?.component === "string" ? { component: qm(pi.component) } : {},
-              ...typeof pi?.interface === "string" ? { interface: qm(pi.interface) } : {},
+              // A re-export names a peer's item: qualified into the declaring
+              // namespace (q), not this subsystem's members' (qm).
+              ...typeof pi?.component === "string" ? { component: (typeof pi?.from === "string" ? q : qm)(pi.component) } : {},
+              ...typeof pi?.interface === "string" ? { interface: (typeof pi?.from === "string" ? q : qm)(pi.interface) } : {},
+              ...typeof pi?.typeDef === "string" ? { typeDef: (typeof pi?.from === "string" ? q : qm)(pi.typeDef) } : {},
+              ...typeof pi?.from === "string" ? { from: qualifySubsystemRef(pi.from, prefix, this.rootSubsystems) } : {},
               ...Array.isArray(pi?.consumers) ? { consumers: pi.consumers.map((c) => typeof c === "string" ? qualifySubsystemRef(c, prefix, this.rootSubsystems) : c) } : {}
             }));
           }
@@ -25398,6 +26027,12 @@ function loadTypeSpecs() {
 function loadTypeSpec(id) {
   return current().loadTypeSpec(id);
 }
+function resolveSubsystemExports(subsystemId) {
+  return resolveSubsystemExportTable(subsystemId);
+}
+function resolveProjectExports() {
+  return resolveProjectExportTable();
+}
 function dryRunSerializeSpecs(include) {
   return current().dryRunSerializeSpecs(include);
 }
@@ -25590,9 +26225,11 @@ function unregisterDomain(id) {
 // src/core/provision.ts
 var fs12 = __toESM(require("fs"));
 var path17 = __toESM(require("path"));
-function defaultProjectConfig(name, now) {
+function defaultProjectConfig(name, now, id) {
+  const declared = id ?? effectiveProjectId({ name });
   return {
     schemaVersion: "1.0.0",
+    ...declared !== null ? { id: declared } : {},
     name,
     projectType: "backend",
     targets: [{ type: "claude", outputDir: ".claude/agents", enabled: true }],
@@ -25634,7 +26271,7 @@ function provisionProject(name) {
   projectConfigRepository.create(config);
   saveSystemSpec(bootstrapSystemSpec(name, now));
 }
-function ensureProjectInitialized(fallbackName) {
+function ensureProjectInitialized(fallbackName, id) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const paths = aiPathsAt(getProjectRoot());
   const hasSystem = fs12.existsSync(paths.specsSystem());
@@ -25646,7 +26283,7 @@ function ensureProjectInitialized(fallbackName) {
   let wroteConfig = false;
   let wroteSystem = false;
   if (!projectConfigRepository.exists()) {
-    projectConfigRepository.create(defaultProjectConfig(name, now));
+    projectConfigRepository.create(defaultProjectConfig(name, now, id));
     wroteConfig = true;
   }
   if (!hasSystem) {
@@ -25727,7 +26364,7 @@ function backfillChainedSubprojectConfigs(projectRoot) {
   walkChainedSubprojects(projectRoot, (childDir, subsystemId) => {
     if (childHasSpecsButNoConfig(childDir)) {
       runWithProjectRoot(childDir, () => {
-        ensureProjectInitialized(subsystemId);
+        ensureProjectInitialized(subsystemId, localSegment(subsystemId));
       });
       backfilled.push(childDir);
     }
@@ -25743,7 +26380,7 @@ function createChainedSubsystem(subsystem, projectName) {
   const childDir = assertContainedProjectPath(getProjectRoot(), projectPath);
   runWithProjectRoot(childDir, () => {
     ensureDir(aiPathsAt(childDir).specsDir());
-    ensureProjectInitialized(projectName);
+    ensureProjectInitialized(projectName, localSegment(subsystem.id));
   });
   invalidateSpecCache();
 }
@@ -25774,6 +26411,9 @@ function moveSubsystemProject(subsystemId, newProjectPath) {
   saveSubsystemSpec({ ...sub, projectPath: nextPath, updatedAt: (/* @__PURE__ */ new Date()).toISOString() });
   invalidateSpecCache();
 }
+function localSegment(subsystemId) {
+  return subsystemId.split("::").pop();
+}
 function toPosixPath(p) {
   return p.replace(/\\/g, "/");
 }
@@ -25810,7 +26450,7 @@ function externalizeSubsystem(subsystemId, projectPath) {
   const childSystemName = foo.name || subsystemId;
   runWithProjectRoot(childDir, () => {
     const now = (/* @__PURE__ */ new Date()).toISOString();
-    projectConfigRepository.create(defaultProjectConfig(childSystemName, now));
+    projectConfigRepository.create(defaultProjectConfig(childSystemName, now, subsystemId));
     ensureDir(path17.join(childDir, ".wai", "specs"));
     saveSystemSpec(bootstrapSystemSpec(childSystemName, now));
   });
@@ -29018,7 +29658,13 @@ function qualifiedComponentId(id) {
   return chained.length === 1 ? chained[0] : id;
 }
 function publicInterfacesReplacement(subsystem, stored, list) {
-  const identity = (pi) => pi.component ? `${pi.component}${pi.interface ? `.${pi.interface}` : ""}` : `${pi.type} ${pi.details}`;
+  const identity = (pi) => {
+    if (pi.from || pi.typeDef) {
+      const item = pi.typeDef ? `type ${pi.typeDef}` : pi.component ?? "*";
+      return `${pi.from ? `${pi.from}:` : ""}${item}${pi.interface ? `.${pi.interface}` : ""}${pi.as ? ` as ${pi.as}` : ""}`;
+    }
+    return pi.component ? `${pi.component}${pi.interface ? `.${pi.interface}` : ""}` : `${pi.type} ${pi.details}`;
+  };
   const restated = /* @__PURE__ */ new Map();
   for (const pi of list) restated.set(identity(pi), (restated.get(identity(pi)) ?? 0) + 1);
   const twice = [...restated].filter(([, n]) => n > 1).map(([key]) => `"${key}"`);
@@ -29031,7 +29677,7 @@ function publicInterfacesReplacement(subsystem, stored, list) {
     const key = identity(pi);
     seen.set(key, (seen.get(key) ?? 0) + 1);
     if (seen.get(key) > (restated.get(key) ?? 0)) {
-      deletes.push(pi.component ? { component: pi.component, interface: pi.interface, action: "delete" } : { type: pi.type, details: pi.details, action: "delete" });
+      deletes.push(pi.from || pi.typeDef ? { from: pi.from, component: pi.component, interface: pi.interface, typeDef: pi.typeDef, as: pi.as, action: "delete" } : pi.component ? { component: pi.component, interface: pi.interface, action: "delete" } : { type: pi.type, details: pi.details, action: "delete" });
     }
   }
   const restatedEntries = list.map((pi) => {
@@ -29656,17 +30302,21 @@ function createMcpServer(options = {}) {
       }
     }
   );
+  const publicInterfaceItemInput = import_zod11.z.object({
+    type: import_zod11.z.enum(["REST", "GraphQL", "MessageBus", "RPC", "Custom"]).optional().describe("Transport kind of an own item (required on an own component item); a re-export inherits its target's"),
+    details: import_zod11.z.string().optional().describe("Consumer-facing description of an own item (required on an own component item); a re-export inherits its target's"),
+    component: import_zod11.z.string().optional().describe("For an own item, the L2 component that realizes it (this subsystem's published surface); for a re-export, the component re-exported from `from`"),
+    interface: import_zod11.z.string().optional().describe("Optional L3 interface id the entry narrows to"),
+    consumers: import_zod11.z.array(import_zod11.z.string()).optional().describe("The subsystem ids this surface is published to. Absent, any subsystem may depend on the component; present, only these may \u2014 when every entry publishing the component names consumers, the union of the lists is the whole set, and a dependency from any other subsystem is CROSS_SUBSYSTEM_UNLISTED_CONSUMER. Every id must name a subsystem of the tree (PUBLIC_INTERFACE_UNKNOWN_CONSUMER)."),
+    from: import_zod11.z.string().optional().describe("Re-export source: another subsystem of this project. With neither component nor typeDef, the entry re-exports everything that subsystem exports (a wildcard)"),
+    typeDef: import_zod11.z.string().optional().describe("A type exported as is: owned by this subsystem, or re-exported from `from`"),
+    as: import_zod11.z.string().optional().describe("The public name; defaults to the narrowed interface, then the component or type id. Must fit [a-z0-9-_]+ (EXPORT_INVALID otherwise)")
+  }).strict();
   const subsystemInput = {
     id: import_zod11.z.string().describe("Lowercase identifier for the subsystem"),
     name: import_zod11.z.string().describe("Human-readable display name"),
     description: import_zod11.z.string().describe("Purpose and details of the subsystem"),
-    publicInterfaces: import_zod11.z.array(import_zod11.z.object({
-      type: import_zod11.z.enum(["REST", "GraphQL", "MessageBus", "RPC", "Custom"]),
-      details: import_zod11.z.string(),
-      component: import_zod11.z.string().optional().describe("The L2 component id that realizes this interface (this subsystem's published surface)"),
-      interface: import_zod11.z.string().optional().describe("Optional L3 interface id on that component backing this entry"),
-      consumers: import_zod11.z.array(import_zod11.z.string()).optional().describe("The subsystem ids this surface is published to. Absent, any subsystem may depend on the component; present, only these may \u2014 when every entry publishing the component names consumers, the union of the lists is the whole set, and a dependency from any other subsystem is CROSS_SUBSYSTEM_UNLISTED_CONSUMER. Every id must name a subsystem of the tree (PUBLIC_INTERFACE_UNKNOWN_CONSUMER).")
-    }).strict()).optional().describe("Public entrypoints exposed by this subsystem, each bound to a realizing component"),
+    publicInterfaces: import_zod11.z.array(publicInterfaceItemInput).optional().describe("The subsystem's export table: its own entrypoints, each bound to a realizing component, and re-exports of what other subsystems of this project export"),
     projectPath: import_zod11.z.string().optional().describe("Relative path to external project root for subsystem chaining"),
     targetLanguage: import_zod11.z.string().optional().describe("Override of the system-level targetLanguage for this subsystem"),
     profile: import_zod11.z.string().optional().describe("Architectural profile override for this subsystem (built-ins: backend, frontend-reactive, frontend-controller, lowlevel-os, game-ecs, realtime-embedded, plc-cyclic; extension packs may add more \u2014 unknown names get UNKNOWN_PROFILE)"),
@@ -29728,16 +30378,10 @@ function createMcpServer(options = {}) {
     server,
     "sdd_set_public_interfaces",
     {
-      description: "Set (replace) an existing subsystem's publicInterfaces, binding each to the component (and optional interface) that realizes it. Use this to backfill bindings once the subsystem's components exist \u2014 cross-subsystem dependencies may only target a published public component. A replacement, not a merge: an entry left out is removed. An entry's identity is its component and interface, so a list naming one identity twice is refused. Written through the authoring seam as one gated delta, and answered with the change report \u2014 every entry added, changed or removed, or that nothing changed \u2014 as structured content beside the sentence.",
+      description: "Set (replace) an existing subsystem's export table (its publicInterfaces). An OWN item binds type + details to the component (and optional interface) that realizes it, or exports a type the subsystem owns (typeDef). A RE-EXPORT names another subsystem of the project in `from` and one component (optionally narrowed with `interface`) or one typeDef from what it exports, optionally renamed with `as` \u2014 `from` alone re-exports everything it exports; type and details are optional on a re-export, which inherits its target's. Use this to backfill bindings once the subsystem's components exist \u2014 cross-subsystem dependencies may only target a component its owning subsystem publishes; a re-export is a name, not a licence. A replacement, not a merge: an entry left out is removed. An own entry's identity is its component and interface, a re-export's its source, item and name, so a list naming one identity twice is refused. Written through the authoring seam as one gated delta, and answered with the change report \u2014 every entry added, changed or removed, or that nothing changed \u2014 as structured content beside the sentence.",
       inputSchema: {
         subsystem: import_zod11.z.string().describe("The L1 subsystem id to update"),
-        publicInterfaces: import_zod11.z.array(import_zod11.z.object({
-          type: import_zod11.z.enum(["REST", "GraphQL", "MessageBus", "RPC", "Custom"]),
-          details: import_zod11.z.string(),
-          component: import_zod11.z.string().optional().describe("The L2 component id that realizes this interface"),
-          interface: import_zod11.z.string().optional().describe("Optional L3 interface id on that component"),
-          consumers: import_zod11.z.array(import_zod11.z.string()).optional().describe("The subsystem ids this surface is published to. Absent, any subsystem may depend on the component; present, only these may \u2014 when every entry publishing the component names consumers, the union of the lists is the whole set, and a dependency from any other subsystem is CROSS_SUBSYSTEM_UNLISTED_CONSUMER. Every id must name a subsystem of the tree (PUBLIC_INTERFACE_UNKNOWN_CONSUMER).")
-        }).strict()).describe("The full replacement list of public interfaces for this subsystem")
+        publicInterfaces: import_zod11.z.array(publicInterfaceItemInput).describe("The full replacement list of the subsystem's export table: own items and re-exports")
       },
       outputSchema: specChangeReportOutput
     },
@@ -30003,7 +30647,7 @@ ${renderChangeReport(report)}`,
     }).strict().optional().describe("Typed acknowledgment of a real caller OUTSIDE the modeled narrative graph. Unused-detection seeds the method as an entrypoint so reachability propagates through its narrative (unlike lint.allow); a method the internal walk already reaches is flagged stale (INVOKED_BY_REDUNDANT). Prefer a `register` narrative step when the wiring is internal."),
     findings: import_zod11.z.array(import_zod11.z.object({
       code: import_zod11.z.string().describe("UPPER_SNAKE finding code, unique within the method; a pack's codes carry the pack prefix (<PACK>_<CODE>)"),
-      severity: import_zod11.z.enum(["error", "warning"]).describe("Default severity, before project severity overrides and draft-context downgrades"),
+      severity: import_zod11.z.enum(["error", "warning", "notice"]).describe("Default severity, before project severity overrides and draft-context downgrades. A notice is reported but never fails the gate"),
       summary: import_zod11.z.string().describe("One line saying what the finding means")
     }).strict()).optional().describe("The finding codes this method can report, each with its default severity and summary. Each declared code must be anchored in the method's source file, as a string literal or a property-access name (UNREALIZED_FINDING). A code is declared once per method; sdd_update_spec upserts and deletes findings by code."),
     ext: import_zod11.z.record(import_zod11.z.unknown()).optional().describe("Opaque pack/tool extension data for this method (namespaced keys) \u2014 preserved verbatim")
@@ -30447,9 +31091,9 @@ ${testsBlock}` : ""}`, deletion);
     {
       description: "Update/patch an existing SDD specification (subsystem, component, interface, implementation, or type) using a granular delta. Updates fields, appends/merges array elements, or inserts/deletes narrative steps. Answers with exactly what changed, and with every path the delta named that the write did not act on. Pass dryRun to be told what it would do without writing it.",
       inputSchema: {
-        kind: import_zod11.z.enum(["system", "subsystem", "component", "interface", "implementation", "type"]).describe("The spec kind to update (system = the singleton L0 \u2014 vision, boundaries, globalRequirements, databases, and publicInterfaces: the project gateway surface, each entry {id, name, subsystem, component, type, details, audience: project|department|instance|partner|external}; id is informational)"),
+        kind: import_zod11.z.enum(["system", "subsystem", "component", "interface", "implementation", "type"]).describe("The spec kind to update (system = the singleton L0 \u2014 vision, boundaries, globalRequirements, databases, and publicInterfaces: the project export table, each entry a re-export {from, component, interface, typeDef, as, name, type, details, audience: project|department|instance|partner|external} \u2014 from alone re-exports everything a subsystem exports, and a legacy {id, subsystem} reads as {as, from})"),
         id: import_zod11.z.string().describe("The ID of the spec to update (namespaced if needed)"),
-        delta: import_zod11.z.record(import_zod11.z.any()).describe(`The partial fields to merge into the spec. ARRAYS UPSERT, they do not replace: an array whose elements carry an identity is merged element-by-element, so a delta naming ONE element leaves the others intact. Identity is "name" or "id" by default, and per field: dispatch by "capability", a listener's mounts by "portal", lifecycle by phase+component+method, emits/subscribesTo by topic+event, trustedLinks by "subsystem", a subsystem's publicInterfaces by component+interface (or type+details for an entry not yet bound to a component), invariants and patterns by "id", lint.allow by "code" AND "at" (an allow covers one occurrence, so several may share a code on one spec), an interface method's findings by "code", boundaries by "name", globalRequirements by "description", switch cases by "value", try catches by "error". Identity merging applies at EVERY depth, including an array INSIDE an element (a method's params, a step's catches). Add "action: 'delete'" (or "remove: true") alongside that identity to REMOVE an element \u2014 including a stale lint allow. Arrays of plain STRINGS (owns, dependsOn, guarantees) carry no per-element identity and are replaced wholesale; pass [] to clear any array outright. To REMOVE an optional field entirely, list it in "unset": e.g. {"unset": ["basePath", "variant"]} \u2014 passing null/undefined means "no change" (they are skipped), and writing "" would leave the field present but empty, which is a different and usually wrong spec. Unsetting a required field is refused by schema validation, which names it. For narrative steps, match by "stepNumber" and use "action: 'insert'" (shifts subsequent steps up) or "action: 'delete'" (shifts subsequent steps down and removes it). Step entries apply in ASCENDING stepNumber order, each against the numbering the earlier entries of the SAME delta left behind \u2014 delete step 3 and step 7 becomes step 6 \u2014 so prefer labels, and restate the step's "label" or "description" on a delete to have it checked against the step actually addressed. Renumbering RELOCATES every flow jump field (onTrueStep/onFalseStep/cases.step/defaultStep/endStep/catches.step/finallyStep/toStep) in the same narrative. A delete is REJECTED when the narrative has no such step, when a jump still targets it (retarget the referrers first), when a restated label/description does not match, or when it is a loop/try/parallel header whose body would be left standing (retype the header first to dissolve the region, then delete it). Changing a step's "type" REBUILDS it for the new type: its description and label are kept and every field the new type cannot carry is dropped (returned as a NOTICE); a delta that retypes AND sets such a field is refused. A step delta is also refused when it carries a marker the merge does not recognise: a non-boolean "remove", an "action" that is neither "insert" nor "delete", a "captureJumps" outside an insert, or no "stepNumber" to address. Inserting AT a jump target relocates those jumps past the inserted step by default (a NOTICE is returned) \u2014 add "captureJumps": true on the inserted step to retarget entry jumps onto it (loop/try endStep region tails always relocate with the body and are never captured). Every jump field has a "*Label" twin (toLabel, onFalseLabel, endLabel, \u2026, and "label" on a cases/catches entry) resolved against step labels AFTER the merge, so a delta may anchor on a label only pre-existing steps carry; a label the delta supplies REPLACES the stored number it twins, while setting the number and its label together in one delta is refused as a contradiction. Reference ids in deltas may use LOCAL names \u2014 they are qualified against the spec's namespace exactly as the loader would. Per-spec lint suppression: set "lint: { allow: [{ code, at, covers, reason }] }" to silence a WARNING or NOTICE code on this spec only (errors always surface; stale allows are flagged). An allow covers EXACTLY the occurrence it names: "at" is the site the finding names (a contract method, an import edge "from -> to", a declared edge "component -> target") and is REQUIRED for a code whose findings report one, while a finding that reports no site is covered only by an allow that names none; "covers" lists the units an aggregating finding reports, and the allow silences it only when every one is listed. This delta is deliberately OPEN below its top level \u2014 the shapes nest further than a schema here should restate \u2014 so a key that is not a field at its depth is not refused, it is NAMED BACK under NO EFFECT in the answer, together with any value the spec already held and any "unset" that removed nothing. Read that list: it is where a nested typo shows up.`),
+        delta: import_zod11.z.record(import_zod11.z.any()).describe(`The partial fields to merge into the spec. ARRAYS UPSERT, they do not replace: an array whose elements carry an identity is merged element-by-element, so a delta naming ONE element leaves the others intact. Identity is "name" or "id" by default, and per field: dispatch by "capability", a listener's mounts by "portal", lifecycle by phase+component+method, emits/subscribesTo by topic+event, trustedLinks by "subsystem", a subsystem's publicInterfaces by component+interface (or type+details for an entry not yet bound to a component, and by from+item+interface+as for a re-export or a type export), invariants and patterns by "id", lint.allow by "code" AND "at" (an allow covers one occurrence, so several may share a code on one spec), an interface method's findings by "code", boundaries by "name", globalRequirements by "description", switch cases by "value", try catches by "error". Identity merging applies at EVERY depth, including an array INSIDE an element (a method's params, a step's catches). Add "action: 'delete'" (or "remove: true") alongside that identity to REMOVE an element \u2014 including a stale lint allow. Arrays of plain STRINGS (owns, dependsOn, guarantees) carry no per-element identity and are replaced wholesale; pass [] to clear any array outright. To REMOVE an optional field entirely, list it in "unset": e.g. {"unset": ["basePath", "variant"]} \u2014 passing null/undefined means "no change" (they are skipped), and writing "" would leave the field present but empty, which is a different and usually wrong spec. Unsetting a required field is refused by schema validation, which names it. For narrative steps, match by "stepNumber" and use "action: 'insert'" (shifts subsequent steps up) or "action: 'delete'" (shifts subsequent steps down and removes it). Step entries apply in ASCENDING stepNumber order, each against the numbering the earlier entries of the SAME delta left behind \u2014 delete step 3 and step 7 becomes step 6 \u2014 so prefer labels, and restate the step's "label" or "description" on a delete to have it checked against the step actually addressed. Renumbering RELOCATES every flow jump field (onTrueStep/onFalseStep/cases.step/defaultStep/endStep/catches.step/finallyStep/toStep) in the same narrative. A delete is REJECTED when the narrative has no such step, when a jump still targets it (retarget the referrers first), when a restated label/description does not match, or when it is a loop/try/parallel header whose body would be left standing (retype the header first to dissolve the region, then delete it). Changing a step's "type" REBUILDS it for the new type: its description and label are kept and every field the new type cannot carry is dropped (returned as a NOTICE); a delta that retypes AND sets such a field is refused. A step delta is also refused when it carries a marker the merge does not recognise: a non-boolean "remove", an "action" that is neither "insert" nor "delete", a "captureJumps" outside an insert, or no "stepNumber" to address. Inserting AT a jump target relocates those jumps past the inserted step by default (a NOTICE is returned) \u2014 add "captureJumps": true on the inserted step to retarget entry jumps onto it (loop/try endStep region tails always relocate with the body and are never captured). Every jump field has a "*Label" twin (toLabel, onFalseLabel, endLabel, \u2026, and "label" on a cases/catches entry) resolved against step labels AFTER the merge, so a delta may anchor on a label only pre-existing steps carry; a label the delta supplies REPLACES the stored number it twins, while setting the number and its label together in one delta is refused as a contradiction. Reference ids in deltas may use LOCAL names \u2014 they are qualified against the spec's namespace exactly as the loader would. Per-spec lint suppression: set "lint: { allow: [{ code, at, covers, reason }] }" to silence a WARNING or NOTICE code on this spec only (errors always surface; stale allows are flagged). An allow covers EXACTLY the occurrence it names: "at" is the site the finding names (a contract method, an import edge "from -> to", a declared edge "component -> target") and is REQUIRED for a code whose findings report one, while a finding that reports no site is covered only by an allow that names none; "covers" lists the units an aggregating finding reports, and the allow silences it only when every one is listed. This delta is deliberately OPEN below its top level \u2014 the shapes nest further than a schema here should restate \u2014 so a key that is not a field at its depth is not refused, it is NAMED BACK under NO EFFECT in the answer, together with any value the spec already held and any "unset" that removed nothing. Read that list: it is where a nested typo shows up.`),
         dryRun: import_zod11.z.boolean().optional().describe("Ask what this delta WOULD do instead of doing it. The whole write runs, the candidate gate included, and the answer is the change report it would have produced \u2014 marked DRY RUN, with nothing stamped and not one byte of the stored file moved. Use it before a delta that renumbers a long narrative.")
       },
       outputSchema: specChangeReportOutput
@@ -30702,7 +31346,9 @@ function loadProjectConfig3() {
   NarrativeStepTypeSchema,
   OutputTargetSchema,
   PATTERN_TYPES,
+  PROJECT_ID_RE,
   PROJECT_KINDS,
+  PUBLIC_NAME_RE,
   PackSelectionSchema,
   ParallelBranchSchema,
   PathsConfigSchema,
@@ -30737,6 +31383,7 @@ function loadProjectConfig3() {
   SurfaceOriginSchema,
   SurfaceSnapshotSchema,
   SurfaceTypeDefSchema,
+  SurfaceTypeExportSchema,
   SwitchCaseSchema,
   SystemPublicInterfaceSchema,
   SystemSpecSchema,
@@ -30807,10 +31454,12 @@ function loadProjectConfig3() {
   discoverPacks,
   dryRunSerializeSpecs,
   effectiveDetail,
+  effectiveProjectId,
   emptyExtensions,
   ensureDir,
   ensureProjectInitialized,
   exportSpecTree,
+  exportTargetKey,
   externalizeSubsystem,
   extractTypeIdentifiers,
   factsFor,
@@ -30851,6 +31500,7 @@ function loadProjectConfig3() {
   internalizeSubsystem,
   isDraftSubsystem,
   isLogic,
+  isOwnComponentEntry,
   isPattern,
   isProjectInitialized,
   isProvidedBy,
@@ -30904,6 +31554,7 @@ function loadProjectConfig3() {
   pathKey,
   pinInstalledPacksAsSelections,
   projectConfigExists,
+  projectIdentity,
   provisionProject,
   qualifiedTypeId,
   readFileOrNull,
@@ -30929,7 +31580,9 @@ function loadProjectConfig3() {
   resolveExpectedOutputPaths,
   resolveImport,
   resolveInstalledPack,
+  resolveProjectExports,
   resolveSubprojectForNamespace,
+  resolveSubsystemExports,
   resolveVariantGuidance,
   retireSpecialists,
   runWithProjectBinding,