@wairon/cli 5.1.1-dev.98 → 5.1.1-dev.99

package/dist/index.js

@@ -3571,6 +3571,8 @@ __export(src_exports, {
   buildCanvasDataModel: () => buildCanvasDataModel,
   buildProjectGraph: () => buildProjectGraph,
   buildRuleContext: () => buildRuleContext,
+  builtinProfileIds: () => builtinProfileIds,
+  builtinProjectKinds: () => builtinProjectKinds,
   callSitesOf: () => callSitesOf,
   canonicalTypeRef: () => canonicalTypeRef,
   canonicalTypeText: () => canonicalTypeText,
@@ -3581,6 +3583,7 @@ __export(src_exports, {
   complexityLevel: () => complexityLevel,
   composeAgentBrief: () => composeAgentBrief,
   composeRuleSequence: () => composeRuleSequence,
+  computeGateStateId: () => computeGateStateId,
   computeOwnStateId: () => computeOwnStateId,
   computeStateId: () => computeStateId,
   computeStateIdAt: () => computeStateIdAt,
@@ -3632,12 +3635,15 @@ __export(src_exports, {
   excerptParent: () => excerpt,
   exportDesign: () => exportDesign3,
   exportSpecTree: () => exportSpecTree,
+  exportSurface: () => exportSurface2,
   exportTargetKey: () => exportTargetKey,
   exportUsage: () => exportUsage,
   externalizeSubsystem: () => externalizeSubsystem,
   extractTypeIdentifiers: () => extractTypeIdentifiers,
   factsFor: () => factsFor,
+  familyApprovals: () => familyApprovals,
   familyNode: () => familyNode,
+  familyRelations: () => familyRelations2,
   fieldTypeRefs: () => fieldTypeRefs,
   fieldTypesOf: () => fieldTypesOf,
   findChainingParent: () => findChainingParent,
@@ -3645,6 +3651,7 @@ __export(src_exports, {
   findLegacySpecFiles: () => findLegacySpecFiles,
   findProjectRoot: () => findProjectRoot,
   findSystemRoot: () => findSystemRoot,
+  findTestsReferencing: () => findTestsReferencing2,
   fromProjectRoot: () => fromProjectRoot,
   generateAgent: () => generateAgent,
   generateAll: () => generateAll,
@@ -3652,12 +3659,14 @@ __export(src_exports, {
   generateDiagramSet: () => generateDiagramSet,
   generateSequenceDiagram: () => generateSequenceDiagram,
   getExporter: () => getExporter,
+  getExternalsStatus: () => getExternalsStatus2,
   getHostedLookup: () => getHostedLookup,
   getLoaderIssues: () => getLoaderIssues,
   getProjectRoot: () => getProjectRoot,
   getProjectRootOverride: () => getProjectRootOverride,
   getRequestParentReach: () => getRequestParentReach,
   getRequestProjectRoot: () => getRequestProjectRoot,
+  getSnapshot: () => getSnapshot2,
   getStatusReport: () => getStatusReport,
   getWriteReach: () => getWriteReach,
   globalGuideFilePath: () => globalGuideFilePath,
@@ -3672,6 +3681,7 @@ __export(src_exports, {
   importBindingOf: () => importBindingOf,
   importNames: () => importNames,
   importSpecTree: () => importSpecTree,
+  importSurface: () => importSurface2,
   injectGuide: () => injectGuide,
   installPackFromDirectory: () => installPackFromDirectory,
   interfaceCanonicalTypes: () => interfaceCanonicalTypes,
@@ -3692,9 +3702,13 @@ __export(src_exports, {
   landReference: () => landReference,
   languageOfSourcePath: () => languageOfSourcePath,
   listDirectChainedSubprojects: () => listDirectChainedSubprojects,
+  listExternals: () => listExternals2,
   listFiles: () => listFiles,
   listFilesRecursive: () => listFilesRecursive,
   listInstalledPacks: () => listInstalledPacks,
+  listPinnedExternals: () => listPinnedExternals2,
+  listRules: () => listRules2,
+  listSnapshots: () => listSnapshots2,
   loadComponentSpec: () => loadComponentSpec,
   loadComponentSpecs: () => loadComponentSpecs,
   loadExtensionPacks: () => loadExtensionPacks,
@@ -3723,6 +3737,8 @@ __export(src_exports, {
   makeScopeFilter: () => makeScopeFilter,
   markSelectionsBundled: () => markSelectionsBundled,
   matchTypeRef: () => matchTypeRef,
+  measurePackDoctrine: () => measurePackDoctrine,
+  measurePackImpact: () => measurePackImpact,
   memberDeclarationOf: () => memberDeclarationOf,
   memberDigest: () => memberDigest,
   memberLocationOf: () => memberLocationOf,
@@ -3751,7 +3767,9 @@ __export(src_exports, {
   passesIntentFloor: () => passesIntentFloor,
   pathExists: () => pathExists,
   pathKey: () => pathKey,
+  pinExternals: () => pinExternals2,
   pinInstalledPacksAsSelections: () => pinInstalledPacksAsSelections,
+  pinnedParent: () => pinnedParent2,
   producerOf: () => producerOf,
   projectConfigExists: () => projectConfigExists,
   projectFamily: () => graph,
@@ -3776,6 +3794,7 @@ __export(src_exports, {
   removeExternal: () => removeExternal,
   removeMember: () => removeMember,
   removePackSelection: () => removePackSelection,
+  removeSnapshot: () => removeSnapshot2,
   renameAlias: () => renameAlias,
   renameComponent: () => renameComponent,
   renameId: () => renameProjectId,
@@ -3846,8 +3865,12 @@ __export(src_exports, {
   updateMember: () => updateMember,
   updateSpec: () => updateSpec,
   upsertPackSelection: () => upsertPackSelection,
+  validateAsComplete: () => validateAsComplete,
+  validateComponentCandidate: () => validateComponentCandidate,
   validateFamily: () => validateFamily,
   validateProject: () => validateProject,
+  validateProjectConfig: () => validateProjectConfig,
+  validateRegistry: () => validateRegistry,
   withPack: () => withPack,
   writeFile: () => writeFile,
   writeFileIfChanged: () => writeFileIfChanged,
@@ -5701,17 +5724,17 @@ function overlayKnownFields(schema, typed, onDisk) {
   }
   return typed;
 }
-function overlayLevel(typed, onDisk, schemaFor) {
+function overlayLevel(typed, onDisk, schemaFor2) {
   const document = isPlainObject(onDisk) ? onDisk : {};
   const out = {};
   for (const [key, stored] of Object.entries(document)) {
-    const schema = schemaFor(key);
+    const schema = schemaFor2(key);
     if (schema === null) out[key] = stored;
     else if (typed[key] !== void 0) out[key] = overlayKnownFields(schema, typed[key], stored);
   }
   for (const [key, value] of Object.entries(typed)) {
     if (hasOwn(document, key) || value === void 0) continue;
-    const schema = schemaFor(key);
+    const schema = schemaFor2(key);
     if (schema !== null) out[key] = overlayKnownFields(schema, value, void 0);
   }
   return out;
@@ -15173,6 +15196,514 @@ function unpin(alias) {
 
 // src/core/openapi.ts
 var yaml2 = __toESM(require("js-yaml"));
+var PRIMITIVE_SCHEMAS = {
+  string: { type: "string" },
+  int: { type: "integer" },
+  float: { type: "number" },
+  bool: { type: "boolean" },
+  bytes: { type: "string", contentEncoding: "base64" },
+  date: { type: "string", format: "date" },
+  datetime: { type: "string", format: "date-time" },
+  duration: { type: "string", format: "duration" },
+  any: {},
+  void: {}
+};
+function expressionOf(typeRef2) {
+  return parseTypeExpression(typeRef2.trim(), "returns").expression;
+}
+function closureHit(name, closureIds) {
+  const local = name.split(/::|\./).pop().toLowerCase().replace(/[^a-z0-9_-]/g, "");
+  return [...closureIds].find((id) => id.toLowerCase() === local);
+}
+function schemaOfExpression(expr, closureIds) {
+  switch (expr.form) {
+    case "primitive":
+      return { ...PRIMITIVE_SCHEMAS[expr.name ?? ""] ?? {} };
+    case "named":
+    case "applied": {
+      const hit = closureHit(expr.name ?? "", closureIds);
+      return hit ? { $ref: `#/components/schemas/${hit}` } : { description: `Unresolved type: ${expr.name}` };
+    }
+    case "list":
+      return { type: "array", items: schemaOfExpression(expr.args[0], closureIds) };
+    case "set":
+      return { type: "array", uniqueItems: true, items: schemaOfExpression(expr.args[0], closureIds) };
+    case "map": {
+      const key = expr.args[0];
+      const keyHit = key.form === "named" ? closureHit(key.name ?? "", closureIds) : void 0;
+      const propertyNames = keyHit ? { propertyNames: { $ref: `#/components/schemas/${keyHit}` } } : key.form === "primitive" && key.name === "int" ? { propertyNames: { pattern: "^-?[0-9]+$" } } : {};
+      return { type: "object", ...propertyNames, additionalProperties: schemaOfExpression(expr.args[1], closureIds) };
+    }
+    case "optional": {
+      const inner2 = schemaOfExpression(expr.args[0], closureIds);
+      if (Object.keys(inner2).length === 0) return inner2;
+      if (typeof inner2.type === "string") return { ...inner2, type: [inner2.type, "null"] };
+      return { anyOf: [inner2, { type: "null" }] };
+    }
+    case "union":
+      return { oneOf: expr.args.map((member) => schemaOfExpression(member, closureIds)) };
+    case "async":
+      return schemaOfExpression(expr.args[0], closureIds);
+  }
+}
+function schemaFor(typeRef2, closureIds) {
+  const expr = expressionOf(typeRef2);
+  if (!expr) return { description: `Not a canonical type expression: ${typeRef2.trim()}` };
+  return schemaOfExpression(expr, closureIds);
+}
+function returnsNothing(returns) {
+  const expr = expressionOf(returns);
+  const inner2 = expr?.form === "async" ? expr.args[0] : expr;
+  return inner2?.form === "primitive" && inner2.name === "void";
+}
+function enumDescription(values) {
+  return ["Values:", ...values.map((v) => `- \`${v.name}\`${v.description ? `: ${v.description}` : ""}`)].join("\n");
+}
+function enumValuesFrom(schema) {
+  const described = /* @__PURE__ */ new Map();
+  if (typeof schema.description === "string") {
+    for (const line of schema.description.split("\n")) {
+      const m = /^- `([^`]+)`: (.+)$/.exec(line.trim());
+      if (m) described.set(m[1], m[2]);
+    }
+  }
+  return schema.enum.filter((v) => typeof v === "string" && v.length > 0).map((name) => ({ name, ...described.has(name) ? { description: described.get(name) } : {} }));
+}
+function operationFor(method, closureIds) {
+  const endpoint = method.endpoint;
+  const httpVerb = endpoint && endpoint.transport === "HTTP" ? endpoint.method.toLowerCase() : "post";
+  const bodyVerbs = /* @__PURE__ */ new Set(["post", "put", "patch"]);
+  const params = method.params ?? [];
+  const op = {
+    operationId: method.name,
+    summary: method.description,
+    responses: {
+      "200": {
+        description: method.returns || "Success",
+        ...method.returns && !returnsNothing(method.returns) ? { content: { "application/json": { schema: schemaFor(method.returns, closureIds) } } } : {}
+      }
+    }
+  };
+  if (method.guarantees?.length) op["x-wairon-guarantees"] = method.guarantees;
+  if (method.effect) op["x-wairon-effect"] = method.effect;
+  if (method.ext && Object.keys(method.ext).length) op["x-wairon-ext"] = method.ext;
+  if (params.length) {
+    if (bodyVerbs.has(httpVerb)) {
+      op.requestBody = {
+        required: true,
+        content: {
+          "application/json": {
+            schema: {
+              type: "object",
+              properties: Object.fromEntries(params.map((p) => [p.name, schemaFor(p.type, closureIds)])),
+              required: params.filter((p) => !p.optional).map((p) => p.name)
+            }
+          }
+        }
+      };
+    } else {
+      op.parameters = params.map((p) => ({
+        name: p.name,
+        in: "query",
+        required: !p.optional,
+        ...p.description ? { description: p.description } : {},
+        schema: schemaFor(p.type, closureIds)
+      }));
+    }
+  }
+  return op;
+}
+var SIGNATURE_EXTENSION = "x-wairon-signature";
+function signatureComponent(t, closureIds) {
+  const params = t.params ?? [];
+  const returns = t.returns ?? "any";
+  const text3 = `(${params.map((p) => `${p.name}${p.optional ? "?" : ""}: ${p.type}`).join(", ")}): ${returns}`;
+  return {
+    title: t.name,
+    description: `A function type ${text3}. A function has no JSON form, so no JSON value of this type can be sent; its params and returns are under ${SIGNATURE_EXTENSION}.`,
+    [SIGNATURE_EXTENSION]: {
+      // Each type twice: as wairon wrote it (what a wairon reader decodes, exactly),
+      // and as a $ref or schema (what an OpenAPI reader can follow).
+      params: params.map((p) => ({
+        name: p.name,
+        type: p.type,
+        schema: schemaFor(p.type, closureIds),
+        ...p.optional ? { optional: true } : {},
+        ...p.description ? { description: p.description } : {}
+      })),
+      returns: { type: returns, schema: schemaFor(returns, closureIds) }
+    }
+  };
+}
+function signatureFromComponent(id, schema) {
+  const raw = schema[SIGNATURE_EXTENSION];
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return void 0;
+  const ext = raw;
+  const typeOf = (entry) => {
+    if (typeof entry.type === "string" && entry.type.trim()) return entry.type;
+    return typeRefFromSchema(entry.schema);
+  };
+  const params = (Array.isArray(ext.params) ? ext.params : []).filter((p) => !!p && typeof p === "object" && typeof p.name === "string").map((p) => ({
+    name: p.name,
+    type: typeOf(p),
+    ...p.optional === true ? { optional: true } : {},
+    ...typeof p.description === "string" ? { description: p.description } : {}
+  }));
+  const returns = ext.returns && typeof ext.returns === "object" && !Array.isArray(ext.returns) ? typeOf(ext.returns) : "any";
+  return { id, name: typeof schema.title === "string" ? schema.title : id, kind: "signature", fields: [], params, returns };
+}
+function securitySchemeObject(auth) {
+  if (auth.scheme === "none") return null;
+  const desc = auth.description ? { description: auth.description } : {};
+  switch (auth.scheme) {
+    case "apiKey":
+      return { type: "apiKey", in: auth.in ?? "header", name: auth.name ?? "X-API-Key", ...desc };
+    case "bearer":
+      return { type: "http", scheme: "bearer", ...auth.bearerFormat ? { bearerFormat: auth.bearerFormat } : {}, ...desc };
+    case "basic":
+      return { type: "http", scheme: "basic", ...desc };
+    case "oauth2": {
+      const flow = { scopes: Object.fromEntries((auth.scopes ?? []).map((s) => [s.name, s.description])) };
+      if (auth.authorizationUrl) flow.authorizationUrl = auth.authorizationUrl;
+      if (auth.tokenUrl) flow.tokenUrl = auth.tokenUrl;
+      if (auth.refreshUrl) flow.refreshUrl = auth.refreshUrl;
+      return { type: "oauth2", flows: { [auth.flow ?? "authorizationCode"]: flow }, ...desc };
+    }
+    case "openIdConnect":
+      return { type: "openIdConnect", openIdConnectUrl: auth.openIdConnectUrl ?? "", ...desc };
+    case "custom":
+      return { type: "apiKey", in: auth.in ?? "header", name: auth.name ?? "Authorization", description: auth.description ?? auth.example ?? "Custom authentication scheme." };
+    default:
+      return null;
+  }
+}
+function schemeBaseName(scheme) {
+  return { apiKey: "ApiKeyAuth", bearer: "BearerAuth", basic: "BasicAuth", oauth2: "OAuth2", openIdConnect: "OpenIdConnect", custom: "CustomAuth" }[scheme] ?? "Auth";
+}
+function buildSecurity(entries) {
+  const schemes = {};
+  const nameByContent = /* @__PURE__ */ new Map();
+  const securityByEntry = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    if (!entry.auth) continue;
+    const obj = securitySchemeObject(entry.auth);
+    if (!obj) continue;
+    const content = JSON.stringify(obj);
+    let name = nameByContent.get(content);
+    if (!name) {
+      name = schemeBaseName(entry.auth.scheme);
+      for (let n = 2; schemes[name]; n++) name = schemeBaseName(entry.auth.scheme) + n;
+      schemes[name] = obj;
+      nameByContent.set(content, name);
+    }
+    const scopeNames = entry.auth.scheme === "oauth2" ? (entry.auth.scopes ?? []).map((s) => s.name) : [];
+    securityByEntry.set(entry.id, { [name]: scopeNames });
+  }
+  return { schemes, securityByEntry };
+}
+function httpEntriesOf(snapshot) {
+  return snapshot.interfaces.filter((e) => e.type === "REST" || e.methods.some((m) => m.endpoint?.transport === "HTTP"));
+}
+function renderDoc(snapshot, entries, closureIds, opts = {}) {
+  const { schemes, securityByEntry } = buildSecurity(entries);
+  const paths = {};
+  for (const entry of entries) {
+    const security = securityByEntry.get(entry.id);
+    for (const method of entry.methods) {
+      const endpoint = method.endpoint;
+      if (!endpoint || endpoint.transport !== "HTTP") continue;
+      const p = endpoint.path.startsWith("/") ? endpoint.path : `/${endpoint.path}`;
+      paths[p] = paths[p] ?? {};
+      paths[p][endpoint.method.toLowerCase()] = {
+        tags: [entry.id],
+        ...operationFor(method, closureIds),
+        ...security ? { security: [security] } : {}
+      };
+    }
+  }
+  const schemas = {};
+  for (const t of snapshot.types) {
+    if (t.kind === "enum") {
+      const values = t.values ?? [];
+      schemas[t.id] = { type: "string", title: t.name, enum: values.map((v) => v.name), description: enumDescription(values) };
+      continue;
+    }
+    if (t.holds !== void 0) {
+      schemas[t.id] = { ...schemaFor(t.holds, closureIds), title: t.name };
+      continue;
+    }
+    schemas[t.id] = t.kind === "signature" ? signatureComponent(t, closureIds) : {
+      type: "object",
+      title: t.name,
+      properties: Object.fromEntries(t.fields.map((f) => [f.name, schemaFor(f.type, closureIds)])),
+      required: t.fields.filter((f) => !f.optional).map((f) => f.name)
+    };
+  }
+  const components = {};
+  if (Object.keys(schemas).length) components.schemas = schemas;
+  if (Object.keys(schemes).length) components.securitySchemes = schemes;
+  const basePaths = [...new Set(entries.map((e) => e.basePath).filter((b) => !!b))];
+  const servers = opts.servers && basePaths.length === 1 ? [{ url: basePaths[0] }] : void 0;
+  return {
+    openapi: "3.1.0",
+    info: {
+      title: opts.title ?? snapshot.projectName,
+      version: snapshot.version ?? "0.0.0",
+      ...snapshot.stateId ? { "x-wairon-state-id": snapshot.stateId } : {},
+      "x-wairon-origin": snapshot.origin,
+      "x-wairon-generated-at": snapshot.generatedAt
+    },
+    ...servers ? { servers } : {},
+    paths,
+    ...Object.keys(components).length ? { components } : {}
+  };
+}
+function toOpenApiSet(snapshot) {
+  const closureIds = new Set(snapshot.types.map((t) => t.id));
+  const byPortal = /* @__PURE__ */ new Map();
+  const order2 = [];
+  for (const entry of httpEntriesOf(snapshot)) {
+    if (!byPortal.has(entry.component)) {
+      byPortal.set(entry.component, []);
+      order2.push(entry.component);
+    }
+    byPortal.get(entry.component).push(entry);
+  }
+  return order2.map((portalId) => {
+    const entries = byPortal.get(portalId);
+    const name = entries[0]?.name ?? portalId;
+    return { portalId, name, document: JSON.stringify(renderDoc(snapshot, entries, closureIds, { title: name, servers: true }), null, 2) };
+  });
+}
+function isOpenApiDocument(body) {
+  try {
+    const parsed = yaml2.load(body);
+    return !!parsed && typeof parsed === "object" && typeof parsed.openapi === "string";
+  } catch {
+    return false;
+  }
+}
+function isNullSchema(schema) {
+  return !!schema && typeof schema === "object" && schema.type === "null";
+}
+function isTopLevelUnion(text3) {
+  let depth = 0;
+  for (const ch of text3) {
+    if (ch === "<" || ch === "(") depth++;
+    else if (ch === ">" || ch === ")") depth--;
+    else if (ch === "|" && depth === 0) return true;
+  }
+  return false;
+}
+function typeRefFromSchema(schema) {
+  if (!schema || typeof schema !== "object") return "any";
+  const ref = schema.$ref;
+  if (typeof ref === "string") return ref.split("/").pop() ?? "any";
+  for (const key of ["anyOf", "oneOf"]) {
+    const members = schema[key];
+    if (!Array.isArray(members) || members.length === 0) continue;
+    const nullable = members.some(isNullSchema);
+    const texts = members.filter((m) => !isNullSchema(m)).map((m) => typeRefFromSchema(m));
+    if (texts.length === 0 || texts.includes("any")) return "any";
+    const text3 = texts.join(" | ");
+    if (!nullable) return text3;
+    return isTopLevelUnion(text3) ? `(${text3})?` : `${text3}?`;
+  }
+  const t = schema.type;
+  if (Array.isArray(t)) {
+    const types = t.filter((x) => typeof x === "string");
+    const nonNull = types.filter((x) => x !== "null");
+    if (nonNull.length !== 1) return "any";
+    const inner2 = typeRefFromSchema({ ...schema, type: nonNull[0] });
+    return types.includes("null") && inner2 !== "any" ? `${inner2}?` : inner2;
+  }
+  if (t === "array") {
+    const elem = typeRefFromSchema(schema.items);
+    return schema.uniqueItems === true ? `set<${elem}>` : `list<${elem}>`;
+  }
+  if (t === "integer") return "int";
+  if (t === "number") return "float";
+  if (t === "boolean") return "bool";
+  if (t === "string") {
+    if (schema.format === "date") return "date";
+    if (schema.format === "date-time") return "datetime";
+    if (schema.format === "duration") return "duration";
+    if (schema.contentEncoding === "base64" || schema.format === "byte" || schema.format === "binary") return "bytes";
+    return "string";
+  }
+  if (t === "object" || t === void 0) {
+    const additional = schema.additionalProperties;
+    if (additional && typeof additional === "object") {
+      const names = schema.propertyNames;
+      const key = names && typeof names.$ref === "string" ? typeRefFromSchema(names) : names && typeof names.pattern === "string" && names.pattern.includes("[0-9]") ? "int" : "string";
+      return `map<${key}, ${typeRefFromSchema(additional)}>`;
+    }
+    if (additional === true) return "map<string, any>";
+  }
+  return "any";
+}
+var SCALAR_SCHEMA_TYPES = /* @__PURE__ */ new Set(["string", "integer", "number", "boolean"]);
+function inlineEnumNote(schema) {
+  if (!schema || schema.$ref !== void 0 || !Array.isArray(schema.enum)) return void 0;
+  const values = schema.enum.filter((v) => typeof v === "string" || typeof v === "number");
+  return values.length ? `One of: ${values.join(", ")}.` : void 0;
+}
+function describedWith(description, note) {
+  const text3 = [description, note].filter((x) => !!x).join(" ");
+  return text3 ? { description: text3 } : {};
+}
+function authFromSecurityScheme(scheme) {
+  const desc = typeof scheme.description === "string" ? { description: scheme.description } : {};
+  if (scheme.type === "apiKey") {
+    return {
+      scheme: "apiKey",
+      ...scheme.in === "header" || scheme.in === "query" || scheme.in === "cookie" ? { in: scheme.in } : {},
+      ...typeof scheme.name === "string" ? { name: scheme.name } : {},
+      ...desc
+    };
+  }
+  if (scheme.type === "http") {
+    if (scheme.scheme === "bearer") return { scheme: "bearer", ...typeof scheme.bearerFormat === "string" ? { bearerFormat: scheme.bearerFormat } : {}, ...desc };
+    if (scheme.scheme === "basic") return { scheme: "basic", ...desc };
+  }
+  if (scheme.type === "oauth2") {
+    const flows = scheme.flows ?? {};
+    const flowKey = Object.keys(flows)[0];
+    const f = flows[flowKey] ?? {};
+    return {
+      scheme: "oauth2",
+      ...flowKey === "authorizationCode" || flowKey === "clientCredentials" || flowKey === "implicit" || flowKey === "password" ? { flow: flowKey } : {},
+      ...typeof f.authorizationUrl === "string" ? { authorizationUrl: f.authorizationUrl } : {},
+      ...typeof f.tokenUrl === "string" ? { tokenUrl: f.tokenUrl } : {},
+      ...typeof f.refreshUrl === "string" ? { refreshUrl: f.refreshUrl } : {},
+      scopes: Object.entries(f.scopes ?? {}).map(([name, description]) => ({ name, description })),
+      ...desc
+    };
+  }
+  if (scheme.type === "openIdConnect") {
+    return { scheme: "openIdConnect", openIdConnectUrl: typeof scheme.openIdConnectUrl === "string" ? scheme.openIdConnectUrl : "", ...desc };
+  }
+  return void 0;
+}
+function fromOpenApi(document, projectName) {
+  let parsed;
+  try {
+    parsed = yaml2.load(document);
+  } catch (e) {
+    throw new Error(`Invalid surface document: not parseable as JSON/YAML (${e instanceof Error ? e.message : String(e)})`);
+  }
+  if (!parsed || typeof parsed !== "object" || typeof parsed.openapi !== "string" || typeof parsed.paths !== "object") {
+    throw new Error('Invalid surface document: missing OpenAPI "openapi"/"paths" structure.');
+  }
+  const info = parsed.info ?? {};
+  const methods = [];
+  for (const [rawPath, ops] of Object.entries(parsed.paths)) {
+    for (const [verb, opRaw] of Object.entries(ops ?? {})) {
+      if (!["get", "post", "put", "delete", "patch", "options", "head"].includes(verb)) continue;
+      const op = opRaw ?? {};
+      const name = typeof op.operationId === "string" && /^[a-zA-Z0-9_]+$/.test(op.operationId) ? op.operationId : `${verb}_${rawPath.replace(/[^a-zA-Z0-9]+/g, "_").replace(/^_+|_+$/g, "")}`;
+      const params = [];
+      for (const p of op.parameters ?? []) {
+        if (typeof p.name !== "string") continue;
+        const schema = p.schema;
+        params.push({
+          name: p.name,
+          type: typeRefFromSchema(schema),
+          ...p.required === true ? {} : { optional: true },
+          ...describedWith(typeof p.description === "string" ? p.description : void 0, inlineEnumNote(schema))
+        });
+      }
+      const bodySchema = op.requestBody?.content?.["application/json"]?.schema;
+      if (bodySchema) {
+        const props = bodySchema.properties ?? {};
+        const required = new Set(bodySchema.required ?? []);
+        if (Object.keys(props).length) {
+          for (const [pname, pschema] of Object.entries(props)) {
+            params.push({
+              name: pname,
+              type: typeRefFromSchema(pschema),
+              ...required.has(pname) ? {} : { optional: true },
+              ...describedWith(typeof pschema.description === "string" ? pschema.description : void 0, inlineEnumNote(pschema))
+            });
+          }
+        } else {
+          params.push({ name: "body", type: typeRefFromSchema(bodySchema) });
+        }
+      }
+      const okResponse = op.responses?.["200"] ?? op.responses?.["201"];
+      const responseSchema = okResponse?.content?.["application/json"]?.schema;
+      const returns = responseSchema ? typeRefFromSchema(responseSchema) : "void";
+      const rawGuarantees = op["x-wairon-guarantees"];
+      const guarantees = Array.isArray(rawGuarantees) ? rawGuarantees.filter((g) => typeof g === "string" && g.length > 0) : [];
+      const rawEffect = op["x-wairon-effect"];
+      const effect = rawEffect === "read" || rawEffect === "write" || rawEffect === "lifecycle" ? rawEffect : void 0;
+      const rawExt = op["x-wairon-ext"];
+      const ext = rawExt && typeof rawExt === "object" && !Array.isArray(rawExt) ? rawExt : void 0;
+      methods.push({
+        name,
+        description: typeof op.summary === "string" ? op.summary : typeof op.description === "string" ? op.description : name,
+        signature: `${name}(${params.map((p) => `${p.name}: ${p.type}`).join(", ")}): ${returns}`,
+        returns,
+        params,
+        endpoint: { transport: "HTTP", method: verb.toUpperCase(), path: rawPath },
+        ...guarantees.length ? { guarantees } : {},
+        ...effect ? { effect } : {},
+        ...ext ? { ext } : {}
+      });
+    }
+  }
+  const types = [];
+  const schemas = parsed.components?.schemas ?? {};
+  for (const [id, schema] of Object.entries(schemas)) {
+    const signature = signatureFromComponent(id, schema);
+    if (signature) {
+      types.push(signature);
+      continue;
+    }
+    if (schema.type === "string" && Array.isArray(schema.enum)) {
+      types.push({ id, name: typeof schema.title === "string" ? schema.title : id, kind: "enum", fields: [], values: enumValuesFrom(schema) });
+      continue;
+    }
+    if (typeof schema.type === "string" && SCALAR_SCHEMA_TYPES.has(schema.type) && schema.properties === void 0) {
+      types.push({ id, name: typeof schema.title === "string" ? schema.title : id, kind: "value-object", fields: [], holds: typeRefFromSchema(schema) });
+      continue;
+    }
+    const props = schema.properties ?? {};
+    const required = new Set(schema.required ?? []);
+    types.push({
+      id,
+      name: typeof schema.title === "string" ? schema.title : id,
+      kind: "value-object",
+      fields: Object.entries(props).map(([fname, fschema]) => ({
+        name: fname,
+        type: typeRefFromSchema(fschema),
+        ...required.has(fname) ? {} : { optional: true }
+      }))
+    });
+  }
+  const securitySchemes = parsed.components?.securitySchemes ?? {};
+  const firstScheme = Object.values(securitySchemes)[0];
+  const importedAuth = firstScheme ? authFromSecurityScheme(firstScheme) : void 0;
+  const entry = {
+    id: `${projectName}-api`,
+    name: typeof info.title === "string" ? info.title : projectName,
+    audience: "external",
+    type: "REST",
+    component: `${projectName}-api`,
+    methods,
+    details: typeof info.description === "string" ? info.description : `Imported OpenAPI surface of ${projectName}.`,
+    ...typeof info.version === "string" ? { version: info.version } : {},
+    ...importedAuth ? { auth: importedAuth } : {}
+  };
+  return SurfaceSnapshotSchema.parse({
+    projectName,
+    origin: "authored",
+    ...typeof info.version === "string" ? { version: info.version } : {},
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    interfaces: [entry],
+    types
+  });
+}
 
 // src/config/defaults.ts
 var os2 = __toESM(require("os"));
@@ -15192,7 +15723,7 @@ function defaultTargetConfig(type) {
     enabled: true
   };
 }
-var WAIRON_VERSION = "5.1.1-dev.98";
+var WAIRON_VERSION = "5.1.1-dev.99";
 var GITHUB_REPO = "SYW-Apps/Waffle-AIron";
 var ARCHITECT_AGENT_ID = "agent-architect";
 var ARCHITECT_TEMPLATE_ID = "architect";
@@ -15814,9 +16345,32 @@ function listSnapshots() {
   }
   return out;
 }
+function getSnapshot(projectName) {
+  return listSnapshots().find((s) => s.projectName === projectName) ?? null;
+}
 function snapshotFilename(projectName) {
   return `${safeFilenamePart(projectName)}.yaml`;
 }
+function writeSnapshotIfChanged(snapshot, rootDir) {
+  const dir = surfacesDir(rootDir);
+  fs9.mkdirSync(dir, { recursive: true });
+  const p = path14.join(dir, snapshotFilename(snapshot.projectName));
+  const next = SurfaceSnapshotSchema.parse(snapshot);
+  if (fs9.existsSync(p)) {
+    try {
+      const existing = SurfaceSnapshotSchema.parse(readYamlFile(p));
+      if (surfaceContentKey(existing) === surfaceContentKey(next)) {
+        return { path: p, changed: false };
+      }
+    } catch {
+    }
+  }
+  writeYamlFile(p, next);
+  return { path: p, changed: true };
+}
+function saveSnapshot(snapshot) {
+  return writeSnapshotIfChanged(snapshot, getProjectRoot()).path;
+}
 function removeSnapshot(projectName) {
   const dir = surfacesDir(getProjectRoot());
   const direct = path14.join(dir, snapshotFilename(projectName));
@@ -15866,6 +16420,53 @@ function listPinnedExternals() {
     return { alias, project: entry.project, entry, snapshot };
   });
 }
+function selectPortalSpec(renderedSet, portalId) {
+  const hit = renderedSet.find((spec) => spec.portalId === portalId);
+  if (!hit) {
+    const known = renderedSet.map((s) => s.portalId).join(", ");
+    throw new Error(`Unknown portal "${portalId}" \u2014 this surface renders: ${known || "(no portals)"}.`);
+  }
+  return [hit];
+}
+function perPortalPath(resolvedOut, portalId) {
+  const ext = path14.extname(resolvedOut);
+  const stem = ext ? resolvedOut.slice(0, -ext.length) : resolvedOut;
+  return `${stem}.${safeFilenamePart(portalId)}${ext}`;
+}
+function writeSurfaceFile(targetPath, snapshot, renderedSet) {
+  const resolved = path14.resolve(targetPath);
+  fs9.mkdirSync(path14.dirname(resolved), { recursive: true });
+  if (!renderedSet || renderedSet.length === 0) {
+    writeYamlFile(resolved, snapshot);
+    return [resolved];
+  }
+  if (renderedSet.length === 1) {
+    fs9.writeFileSync(resolved, renderedSet[0].document);
+    return [resolved];
+  }
+  return renderedSet.map((spec) => {
+    const target = perPortalPath(resolved, spec.portalId);
+    fs9.writeFileSync(target, spec.document);
+    return target;
+  });
+}
+function exportResult(snapshot, renderedSet, writtenPaths) {
+  const rendered = renderedSet?.length === 1 ? renderedSet[0].document : void 0;
+  return {
+    snapshot,
+    ...rendered !== void 0 ? { rendered } : {},
+    ...renderedSet ? { renderedSet } : {},
+    ...writtenPaths.length === 1 ? { writtenTo: writtenPaths[0] } : {},
+    ...writtenPaths.length ? { writtenPaths } : {}
+  };
+}
+function exportSurface(maxAudience, format, outPath, portalId) {
+  const snapshot = projectOwnSurface(maxAudience);
+  let renderedSet = format === "openapi" ? toOpenApiSet(snapshot) : void 0;
+  if (renderedSet && portalId) renderedSet = selectPortalSpec(renderedSet, portalId);
+  const writtenPaths = outPath ? writeSurfaceFile(outPath, snapshot, renderedSet) : [];
+  return exportResult(snapshot, renderedSet, writtenPaths);
+}
 function withSortedKeys(value) {
   if (Array.isArray(value)) return value.map(withSortedKeys);
   if (value && typeof value === "object") {
@@ -15892,6 +16493,28 @@ function exportDesign2(outPath, approval) {
   if (outPath) writeDesignTo(outPath, design);
   return design;
 }
+function readSurfaceDocument(sourcePath) {
+  const resolved = path14.resolve(sourcePath);
+  if (!fs9.existsSync(resolved)) {
+    throw new Error(`Surface document not found: ${resolved}`);
+  }
+  return fs9.readFileSync(resolved, "utf8");
+}
+function importSurface(sourcePath, origin) {
+  const resolved = path14.resolve(sourcePath);
+  const body = readSurfaceDocument(resolved);
+  let snapshot;
+  if (isOpenApiDocument(body)) {
+    const projectName = path14.basename(resolved).replace(/\.(json|ya?ml)$/i, "");
+    snapshot = fromOpenApi(body, projectName);
+    snapshot = { ...snapshot, origin };
+  } else {
+    snapshot = SurfaceSnapshotSchema.parse(parseYaml(body, resolved));
+    snapshot = { ...snapshot, origin };
+  }
+  saveSnapshot(snapshot);
+  return snapshot;
+}
 function listFamilyPins() {
   const snapshots = listSnapshots();
   const pins = snapshots.filter((snapshot) => snapshot.origin === "generated").map((snapshot) => ({
@@ -16162,20 +16785,30 @@ function listExternals() {
     };
   });
 }
+function surfaceContentKey(snapshot) {
+  const { stateId, generatedAt, origin, ...content } = snapshot;
+  return JSON.stringify(content);
+}
 
 // src/core/surface-portal.ts
+function exportSurface2(maxAudience, format, outPath, portalId) {
+  return exportSurface(maxAudience, format, outPath, portalId);
+}
 function exportDesign3(outPath, approval) {
   return exportDesign2(outPath, approval);
 }
+function importSurface2(sourcePath, origin) {
+  return importSurface(sourcePath, origin);
+}
 function listSnapshots2() {
   return listSnapshots();
 }
+function getSnapshot2(projectName) {
+  return getSnapshot(projectName);
+}
 function removeSnapshot2(projectName) {
   return removeSnapshot(projectName);
 }
-function listFamilyPins2() {
-  return listFamilyPins();
-}
 function pinExternals2(aliases) {
   return pinExternals(aliases);
 }
@@ -16188,12 +16821,6 @@ function listExternals2() {
 function listPinnedExternals2() {
   return listPinnedExternals();
 }
-function renamePin2(alias, newAlias, project) {
-  return renamePin(alias, newAlias, project);
-}
-function unpin2(alias) {
-  return unpin(alias);
-}
 function pinnedParent2() {
   return pinnedParent();
 }
@@ -16711,6 +17338,86 @@ function projectApprovals(depth) {
   }
   return entries;
 }
+function relationReach(root) {
+  const granted = getRequestParentReach();
+  if (!granted) return null;
+  const lookup2 = getHostedLookup();
+  const base = granted.parentReach ? { topRoot: granted.topRoot ?? root, parentReach: true, ...granted.narrowed ? { narrowed: true } : {} } : { topRoot: root, parentReach: true, narrowed: true };
+  return { ...base, ...lookup2 ? { hostedLookup: lookup2 } : {} };
+}
+function outsideReach(node) {
+  const lookup2 = getHostedLookup();
+  if (!lookup2 || node.namespace === "") return null;
+  return lookup2(node.id ?? node.namespace) === null ? `the project "${node.id ?? node.namespace}" lies outside this request's reach` : null;
+}
+function referenceUse(ref) {
+  return ref.publicName ?? ref.resolved.split("::").pop() ?? ref.authored;
+}
+function failureAt(ref, failures) {
+  const site = `${ref.specId} (${ref.position})`;
+  const last = ref.resolved.split("::").pop() ?? "";
+  return failures.find((i) => i.resolution.callSite === site && (i.resolution.canonicalTarget === ref.authored || (i.resolution.canonicalTarget ?? "").endsWith(`::${last}`)));
+}
+function containedStatus(child, refs, failures) {
+  const base = { alias: child.mountAlias, project: child.id ?? child.namespace, sourceKind: "family", pinned: false };
+  const unreachable = outsideReach(child);
+  if (unreachable) {
+    const uses2 = [...new Set(refs.map(referenceUse))].map((name) => ({ publicName: name, state: "unavailable", code: "EXTERNAL_CHECK_UNAVAILABLE", detail: unreachable }));
+    return { ...base, reachable: false, stale: false, outOfReach: true, uses: uses2, detail: unreachable };
+  }
+  const uses = [];
+  for (const ref of refs) {
+    const failed = failureAt(ref, failures);
+    const use = failed ? { publicName: referenceUse(ref), state: "removed", code: failed.code, detail: failed.resolution.reason } : { publicName: referenceUse(ref), state: "unchanged" };
+    if (!uses.some((u) => u.publicName === use.publicName && u.state === use.state)) uses.push(use);
+  }
+  return { ...base, reachable: true, stale: uses.some((u) => u.state === "removed"), uses, detail: "a contained member, read live \u2014 nothing is pinned" };
+}
+function containedRelations(answered) {
+  const own = graph();
+  const consumed = own.nodes.filter((n) => n.parent === "" && n.mountAlias !== void 0 && !answered.some((s) => s.alias === n.mountAlias)).map((child) => ({
+    child,
+    refs: own.authoredReferences.filter((r) => (own.owners.get(r.specId) ?? "") === "" && r.producer === child.namespace && r.binding !== "local")
+  })).filter((c) => c.refs.length > 0);
+  if (consumed.length === 0) return [];
+  const config = configOrNull();
+  const failures = validateProject({ rules: config?.rules, projectType: config?.projectType }).issues.filter((i) => i.resolution !== void 0 && i.resolution.outcome !== "resolved");
+  return consumed.map(({ child, refs }) => containedStatus(child, refs, failures));
+}
+function relationsAt(key, dir, reach2) {
+  const bound2 = (fn) => reach2 === null ? runWithProjectRoot(dir, fn) : runWithProjectBinding(dir, reach2, fn);
+  return bound2(() => {
+    const statuses = getExternalsStatus2();
+    const contained = containedRelations(statuses);
+    return { project: key, externals: [...statuses, ...contained], comparedAt: (/* @__PURE__ */ new Date()).toISOString() };
+  });
+}
+function unopened(key, detail) {
+  return { project: key, externals: [], comparedAt: (/* @__PURE__ */ new Date()).toISOString(), detail };
+}
+function familyRelations() {
+  const family = graph();
+  const root = path15.resolve(getProjectRoot());
+  const reach2 = relationReach(root);
+  const out = [];
+  for (const node of family.nodes) {
+    const unreachable = outsideReach(node);
+    if (unreachable || !fs10.existsSync(node.directory)) {
+      out.push(unopened(node.namespace, unreachable ?? `its root ${node.directory} does not exist`));
+      continue;
+    }
+    out.push(relationsAt(node.namespace, node.directory, reach2));
+  }
+  for (const ref of referencedOf(family.nodes)) {
+    if (ref.directory === void 0) {
+      out.push(unopened(ref.key, ref.problem ?? "its root could not be located"));
+      continue;
+    }
+    const lookup2 = getHostedLookup();
+    out.push(relationsAt(ref.key, ref.directory, { topRoot: ref.directory, parentReach: true, narrowed: true, ...lookup2 ? { hostedLookup: lookup2 } : {} }));
+  }
+  return out;
+}
 function requiredBy(key) {
   return key === "" ? "the family root" : `"${key}"`;
 }
@@ -27650,6 +28357,11 @@ function measure(candidate) {
     after: totals(next, after)
   };
 }
+function doctrine(manifest) {
+  const baseline = defaultsBaseline();
+  const changes = doctrineChanges(manifest, baseline);
+  return { pack: manifest.name, ...manifest.version ? { version: manifest.version } : {}, changes };
+}
 
 // src/core/rules/gate-identity.ts
 var crypto4 = __toESM(require("crypto"));
@@ -27737,6 +28449,16 @@ function computeGateIdentity(content, doctrine2, builtinRules, inputs, gate, mem
   const digest3 = crypto4.createHash("sha256").update(canonicalize(payload)).digest("hex");
   return { algorithm: GATE_ALGORITHM, digest: digest3 };
 }
+function analyzerDigest(builtinRules, gate) {
+  const codeCodes = codeJudgedCodes(builtinRules);
+  const overrides = Object.entries(gate.rules?.sddRuleSeverity ?? {}).filter(([code]) => codeCodes.has(code));
+  const payload = {
+    rules: ruleIdentities(builtinRules.filter(judgesCode)),
+    conformance: gate.rules?.conformance ?? null,
+    severities: byKey2(overrides, ([code]) => code).map(([code, severity]) => ({ code, severity }))
+  };
+  return crypto4.createHash("sha256").update(canonicalize(payload)).digest("hex");
+}
 
 // src/core/validation.ts
 function projectPackSelections() {
@@ -27832,6 +28554,29 @@ function checkOverlappingOwnership(agents, issues) {
     }
   }
 }
+function validateProjectConfig(config) {
+  const issues = [];
+  if (config.targets.length === 0) {
+    issues.push(issue("error", "NO_TARGETS", "No output targets configured in project.yaml"));
+  }
+  const enabled = config.targets.filter((t) => {
+    if (typeof t === "string") return true;
+    return t.enabled !== false;
+  });
+  if (enabled.length === 0) {
+    issues.push(issue("error", "NO_ENABLED_TARGETS", "All configured targets are disabled"));
+  }
+  return {
+    valid: issues.every((i) => i.severity !== "error"),
+    issues
+  };
+}
+function listRules2() {
+  const extensions = loadProjectExtensions();
+  registerBuiltinRules();
+  registerPackRules(extensions.rules);
+  return ruleSequence();
+}
 function memberOwning(owners, memberKeys, key) {
   const owner = owners.get(key);
   if (owner !== void 0) return owner === "" ? void 0 : owner;
@@ -28171,12 +28916,45 @@ function settledStatusBearing(loaded) {
   take(loaded.implementations, index.paths.implementation);
   return out;
 }
+function validateAsComplete(options) {
+  const { result, codeModel } = runOwnersGate({ ...options ?? {}, treatAllAsComplete: true });
+  const sequence = ruleSequence();
+  const doctrineDigest = analyzerDigest(sequence, { rules: options?.rules ?? projectRules() });
+  return { ...result, analysis: codeAnalysisOf(result, sequence, codeModel, doctrineDigest) };
+}
+function projectRules() {
+  try {
+    return loadProjectConfig()?.rules;
+  } catch {
+    return void 0;
+  }
+}
+var GRADE_ORDER = ["generic", "pattern", "exact"];
+function weakestGrade(codeModel) {
+  const grades = codeModel.files.filter((f) => f.status === "analyzed" && f.analysisGrade).map((f) => GRADE_ORDER.indexOf(f.analysisGrade));
+  return grades.length ? GRADE_ORDER[Math.min(...grades)] : "none";
+}
+function codeAnalysisOf(result, sequence, codeModel, doctrineDigest) {
+  const codes = [...new Set(sequence.filter(judgesCode).flatMap((r) => r.codes.map((c) => c.code)))].sort();
+  const codeSet = new Set(codes);
+  const count = (severity) => result.issues.filter((i) => codeSet.has(i.code) && i.severity === severity).length;
+  return {
+    analyzer: { validatorVersion: WAIRON_VERSION, doctrineDigest, grade: weakestGrade(codeModel) },
+    codes,
+    errors: count("error"),
+    warnings: count("warning"),
+    notices: count("notice")
+  };
+}
 function validateFamily(options) {
   return run(options);
 }
 function measurePackImpact(candidate) {
   return measure(candidate);
 }
+function measurePackDoctrine(manifest) {
+  return doctrine(manifest);
+}
 function builtinProfileIds() {
   return [...BUILTIN_PROFILES];
 }
@@ -28220,6 +28998,9 @@ function directMemberSubjects() {
 function familyApprovals(depth) {
   return projectApprovals(depth);
 }
+function familyRelations2() {
+  return familyRelations();
+}
 
 // src/core/diagram.ts
 function renderDiagram(format, relations) {
@@ -39957,6 +40738,17 @@ var path47 = __toESM(require("path"));
 // src/migrations/chaining-migration.ts
 var path42 = __toESM(require("path"));
 
+// src/core/pin-maintenance-portal.ts
+function renamePin2(alias, newAlias, project) {
+  return renamePin(alias, newAlias, project);
+}
+function unpin2(alias) {
+  return unpin(alias);
+}
+function listFamilyPins2() {
+  return listFamilyPins();
+}
+
 // src/migrations/position-migration.ts
 var path41 = __toESM(require("path"));
 
@@ -45266,6 +46058,8 @@ function loadProjectConfig3() {
   buildCanvasDataModel,
   buildProjectGraph,
   buildRuleContext,
+  builtinProfileIds,
+  builtinProjectKinds,
   callSitesOf,
   canonicalTypeRef,
   canonicalTypeText,
@@ -45276,6 +46070,7 @@ function loadProjectConfig3() {
   complexityLevel,
   composeAgentBrief,
   composeRuleSequence,
+  computeGateStateId,
   computeOwnStateId,
   computeStateId,
   computeStateIdAt,
@@ -45327,12 +46122,15 @@ function loadProjectConfig3() {
   excerptParent,
   exportDesign,
   exportSpecTree,
+  exportSurface,
   exportTargetKey,
   exportUsage,
   externalizeSubsystem,
   extractTypeIdentifiers,
   factsFor,
+  familyApprovals,
   familyNode,
+  familyRelations,
   fieldTypeRefs,
   fieldTypesOf,
   findChainingParent,
@@ -45340,6 +46138,7 @@ function loadProjectConfig3() {
   findLegacySpecFiles,
   findProjectRoot,
   findSystemRoot,
+  findTestsReferencing,
   fromProjectRoot,
   generateAgent,
   generateAll,
@@ -45347,12 +46146,14 @@ function loadProjectConfig3() {
   generateDiagramSet,
   generateSequenceDiagram,
   getExporter,
+  getExternalsStatus,
   getHostedLookup,
   getLoaderIssues,
   getProjectRoot,
   getProjectRootOverride,
   getRequestParentReach,
   getRequestProjectRoot,
+  getSnapshot,
   getStatusReport,
   getWriteReach,
   globalGuideFilePath,
@@ -45367,6 +46168,7 @@ function loadProjectConfig3() {
   importBindingOf,
   importNames,
   importSpecTree,
+  importSurface,
   injectGuide,
   installPackFromDirectory,
   interfaceCanonicalTypes,
@@ -45387,9 +46189,13 @@ function loadProjectConfig3() {
   landReference,
   languageOfSourcePath,
   listDirectChainedSubprojects,
+  listExternals,
   listFiles,
   listFilesRecursive,
   listInstalledPacks,
+  listPinnedExternals,
+  listRules,
+  listSnapshots,
   loadComponentSpec,
   loadComponentSpecs,
   loadExtensionPacks,
@@ -45418,6 +46224,8 @@ function loadProjectConfig3() {
   makeScopeFilter,
   markSelectionsBundled,
   matchTypeRef,
+  measurePackDoctrine,
+  measurePackImpact,
   memberDeclarationOf,
   memberDigest,
   memberLocationOf,
@@ -45446,7 +46254,9 @@ function loadProjectConfig3() {
   passesIntentFloor,
   pathExists,
   pathKey,
+  pinExternals,
   pinInstalledPacksAsSelections,
+  pinnedParent,
   producerOf,
   projectConfigExists,
   projectFamily,
@@ -45471,6 +46281,7 @@ function loadProjectConfig3() {
   removeExternal,
   removeMember,
   removePackSelection,
+  removeSnapshot,
   renameAlias,
   renameComponent,
   renameId,
@@ -45541,8 +46352,12 @@ function loadProjectConfig3() {
   updateMember,
   updateSpec,
   upsertPackSelection,
+  validateAsComplete,
+  validateComponentCandidate,
   validateFamily,
   validateProject,
+  validateProjectConfig,
+  validateRegistry,
   withPack,
   writeFile,
   writeFileIfChanged,