@aotter/mantle 0.2.0-alpha.8 → 0.2.0

package/dist/domain/describe/chunk-ZVXBGP7Y.js

@@ -1,424 +0,0 @@
-// src/build/spec/domain/model/ManifestGrammar.ts
-function resolveLocalizedText(value, preferred, canonical2) {
-  if (value == null) return null;
-  if (typeof value === "string") return value;
-  if (Object.prototype.hasOwnProperty.call(value, preferred)) {
-    return value[preferred];
-  }
-  if (canonical2 && Object.prototype.hasOwnProperty.call(value, canonical2)) {
-    return value[canonical2];
-  }
-  const firstKey = Object.keys(value)[0];
-  return firstKey !== void 0 ? value[firstKey] : null;
-}
-var INPUT_RULE_KEYWORDS = ["dependentRequired", "anyOf", "if", "then", "else"];
-
-// src/build/spec/domain/service/RootRefChain.ts
-function lookupLocalRef(root, ref) {
-  if (typeof ref !== "string" || !ref.startsWith("#/")) return void 0;
-  let value = root;
-  try {
-    for (const key of decodeURIComponent(ref.slice(2)).split("/").map((key2) => key2.replace(/~1/g, "/").replace(/~0/g, "~"))) value = value && typeof value === "object" && Object.hasOwn(value, key) ? value[key] : void 0;
-  } catch {
-    return void 0;
-  }
-  return value && typeof value === "object" ? value : void 0;
-}
-function rootRefChain(input) {
-  const chain = [];
-  for (let schema = input; schema !== void 0; schema = lookupLocalRef(input, schema.$ref)) {
-    if (chain.includes(schema)) return void 0;
-    chain.push(schema);
-    if (schema.$ref === void 0) return chain;
-  }
-  return void 0;
-}
-
-// src/build/spec/domain/service/McpToolNaming.ts
-function mcpToolNameSegment(name) {
-  return name.toLowerCase().replace(/-/g, "_");
-}
-function toolTitle(name) {
-  const words = name.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[-_.\s]+/g, " ").trim().toLowerCase();
-  return words.charAt(0).toUpperCase() + words.slice(1);
-}
-var viewAnnotations = { readOnlyHint: true, destructiveHint: false };
-function procedureAnnotations(p) {
-  const readOnlyHint = p.mcp?.readOnlyHint ?? false;
-  return { readOnlyHint, destructiveHint: !readOnlyHint && ("ref" in p.handler || overwrites(p.handler.sql.stmts)), ...p.mcp };
-}
-var overwrites = (node) => !!node && typeof node === "object" && ("DeleteStmt" in node || "UpdateStmt" in node || node.onConflictClause?.action === "ONCONFLICT_UPDATE" || Object.values(node).some(overwrites));
-function mcpTools(plan, surface, locale = "en") {
-  const text = (t) => resolveLocalizedText(t, locale, "en") ?? void 0;
-  const tools = /* @__PURE__ */ new Map();
-  const add = (tool) => {
-    const prior = tools.get(tool.name);
-    if (prior && (prior.kind !== tool.kind || prior.source !== tool.source)) throw new TypeError(`MCP tool '${tool.name}' comes from both '${prior.source}' and '${tool.source}'.`);
-    tools.set(tool.name, tool);
-  };
-  for (const t of Object.values(plan.triggers)) {
-    if (t.source.kind !== "mcp" || t.source.surface !== surface) continue;
-    const p = plan.procedures[t.procedure];
-    const title = text(p.title);
-    add({
-      name: mcpToolNameSegment(t.procedure),
-      kind: "procedure",
-      source: t.procedure,
-      title: title ?? toolTitle(t.procedure),
-      description: text(p.description) ?? title ?? t.procedure,
-      inputSchema: p.input,
-      // structuredContent must be an object
-      ...p.output.type === "object" ? { outputSchema: p.output } : {},
-      annotations: procedureAnnotations(p),
-      requires: p.requires
-    });
-  }
-  for (const [name, v] of Object.entries(plan.views)) {
-    if (v.surface !== surface) continue;
-    const chain = (v.input ? rootRefChain(v.input) ?? [v.input] : []).reverse();
-    const props = Object.assign({}, ...chain.map((s) => s.properties ?? {}));
-    const required = [...new Set(chain.flatMap((s) => s.required ?? []))];
-    if ("limit" in props || "cursor" in props) throw new TypeError(`View '${name}' declares an input named limit or cursor; the MCP tool reserves both for paging.`);
-    const rules = chain.map((s) => Object.fromEntries(INPUT_RULE_KEYWORDS.flatMap((k) => s[k] === void 0 ? [] : [[k, s[k]]]))).filter((r) => Object.keys(r).length);
-    const defs = v.input ? referencedDefs(v.input, props) : {};
-    const title = text(v.title);
-    add({
-      name: mcpToolNameSegment(name),
-      kind: "view",
-      source: name,
-      title: title ?? toolTitle(name),
-      description: text(v.description) ?? title ?? name,
-      inputSchema: {
-        type: "object",
-        properties: { ...props, limit: { type: "integer", minimum: 1, maximum: 500 }, cursor: { type: "string" } },
-        ...required.length ? { required } : {},
-        ...rules.length > 1 ? { allOf: rules } : rules[0],
-        ...Object.keys(defs).length ? { $defs: defs } : {}
-      },
-      annotations: viewAnnotations,
-      requires: v.requires
-    });
-  }
-  return [...tools.values()];
-}
-function referencedDefs(root, node, found = {}) {
-  if (!node || typeof node !== "object") return found;
-  const ref = node.$ref, [head, segment] = typeof ref === "string" && ref.startsWith("#/") ? decoded(ref.slice(2)).split("/") : [];
-  const key = head === "$defs" ? segment?.replace(/~1/g, "/").replace(/~0/g, "~") : void 0;
-  if (key !== void 0 && !Object.hasOwn(found, key) && root.$defs && Object.hasOwn(root.$defs, key)) {
-    found[key] = root.$defs[key];
-    referencedDefs(root, found[key], found);
-  }
-  for (const child of Object.values(node)) referencedDefs(root, child, found);
-  return found;
-}
-var decoded = (pointer) => {
-  try {
-    return decodeURIComponent(pointer);
-  } catch {
-    return "";
-  }
-};
-
-// src/build/spec/domain/service/PlanFingerprint.ts
-function canonical(v) {
-  if (Array.isArray(v)) return `[${v.map(canonical).join(",")}]`;
-  if (v && typeof v === "object")
-    return `{${Object.keys(v).sort().filter((k) => v[k] !== void 0).map((k) => `${JSON.stringify(k)}:${canonical(v[k])}`).join(",")}}`;
-  return JSON.stringify(v) ?? "null";
-}
-
-// src/domain/generated-tools.ts
-var publishingTransitions = [["publish", ["draft"], "published"], ["unpublish", ["published", "archived"], "draft"], ["archive", ["draft", "published"], "archived"]];
-var publishingInput = { type: "object", properties: { id: { type: "string", minLength: 1 }, expectedVersion: { type: "integer", minimum: 1 } }, required: ["id", "expectedVersion"], additionalProperties: false };
-function mediaDefinitions() {
-  const define = (name, description, inputSchema, action, readOnlyHint = false) => ({ name, description, inputSchema, action, annotations: { readOnlyHint, destructiveHint: action === "delete", openWorldHint: true } });
-  const string = { type: "string" };
-  const texts = { alt: { type: "string", maxLength: 1e3 }, caption: { type: "string", maxLength: 1e3 } };
-  const input = (properties, required = []) => ({ type: "object", properties, required, additionalProperties: false });
-  return [
-    define("get_media_upload_policy", "Read declared image purpose MIME slots and byte caps before preparing variants or requesting an upload. Optimization runs locally, never in the host.", input({}), "policy", true),
-    define("create_media_upload", "Create short-lived PUT capabilities for image variants. Read site media purpose policy first; optimize images locally. Obtain attachment bytes yourself, then PUT each variant with its requiredHeaders and call commit_media_upload. Never store upload URLs as published images or ask the user to run terminal commands.", input({ filename: { type: "string", maxLength: 255 }, purpose: string, variants: { type: "array", minItems: 1, items: input({ mimeType: string, byteSize: { type: "integer", minimum: 1 }, role: { type: "string", enum: ["primary", "alternate", "fallback"] } }, ["mimeType", "byteSize", "role"]) }, ...texts }, ["filename", "purpose", "variants"]), "create"),
-    define("commit_media_upload", "Verify all uploaded variants and commit one permanent media asset. Store the returned asset id in fields referencing media_assets.id, never a temporary upload URL. Unknown or expired upload groups require a new create_media_upload.", input({ uploadGroupId: string, ...texts }, ["uploadGroupId"]), "commit"),
-    define("list_media_assets", "List committed image assets, newest first, with their permanent variants and alt/caption. Search matches id, alt or caption; reuse only a returned cursor.", input({ limit: { type: "integer", minimum: 1, maximum: 500 }, cursor: string, search: string }), "list", true),
-    define("get_media_asset", "Read one committed media asset and its permanent variant URLs.", input({ id: string }, ["id"]), "get", true),
-    define("update_media_asset", "Update committed asset alt or caption; omitted fields remain unchanged and empty strings clear text.", input({ id: string, ...texts }, ["id"]), "update"),
-    define("delete_media_asset", "Delete an asset's objects and library record. Check application references first. A partial failure can be retried using the same id.", input({ id: string }, ["id"]), "delete")
-  ];
-}
-
-// src/domain/describe/targets.ts
-function inspectSql(value) {
-  const schemas = /* @__PURE__ */ new Set(), readSchemas = /* @__PURE__ */ new Set();
-  const writes = [];
-  let readOnly = true;
-  const walk = (v) => {
-    if (!v || typeof v !== "object") return;
-    const n = v;
-    if (n.RangeVar?.mantle === "table") {
-      schemas.add(n.RangeVar.relname.toLowerCase());
-      readSchemas.add(n.RangeVar.relname.toLowerCase());
-    }
-    for (const kind of ["InsertStmt", "UpdateStmt", "DeleteStmt"]) if (n[kind]) {
-      readOnly = false;
-      if (n[kind].relation?.relname) writes.push({ schema: n[kind].relation.relname.toLowerCase(), operation: kind === "InsertStmt" ? "create" : kind === "UpdateStmt" ? "update" : "delete" });
-      if (n[kind].relation?.relname) {
-        schemas.add(n[kind].relation.relname.toLowerCase());
-        if (kind !== "InsertStmt") readSchemas.add(n[kind].relation.relname.toLowerCase());
-      }
-    }
-    Object.values(n).forEach(walk);
-  };
-  walk(value);
-  return { schemas: [...schemas].sort(), readSchemas: [...readSchemas].sort(), readOnly, writes };
-}
-function mergeRestrict(policies, conjunctive) {
-  return Object.fromEntries([...new Set(policies.flatMap((p) => Object.keys(p)))].sort().map((schema) => {
-    const rows = policies.map((p) => p[schema] ?? { terms: [] });
-    const terms = [...new Map(rows.flatMap((p) => p.terms).map((t) => [canonical(t), t])).values()].filter((t) => conjunctive || rows.every((p) => p.terms.some((v) => canonical(v) === canonical(t))));
-    const owner = rows.find((p) => p.owner)?.owner;
-    return [schema, { ...owner && (conjunctive || rows.every((p) => p.owner === owner)) ? { owner } : {}, terms }];
-  }));
-}
-function inspectBehavior(plan, ir, opaque, requires, restrict, writes) {
-  const inspected = inspectSql(ir);
-  if (writes) {
-    inspected.writes = [...writes];
-    inspected.schemas.push(...writes.map((w) => w.schema));
-    inspected.readSchemas.push(...writes.filter((w) => w.operation !== "create").map((w) => w.schema));
-  }
-  const dependencies = [], policies = [restrict ?? {}];
-  const procedures = /* @__PURE__ */ new Set(), hooks = /* @__PURE__ */ new Set();
-  const visit = (name) => {
-    if (procedures.has(name)) return;
-    procedures.add(name);
-    const p = plan.procedures[name];
-    if (!p) throw new TypeError(`Unknown dependency '${name}'.`);
-    dependencies.push({ procedure: name, declaration: p });
-    policies.push(p.restrict ?? {});
-    opaque ||= "ref" in p.handler;
-    const g = inspectSql("sql" in p.handler ? p.handler.sql.stmts : void 0);
-    inspected.schemas.push(...g.schemas);
-    inspected.readSchemas.push(...g.readSchemas);
-    inspected.writes.push(...g.writes);
-    inspected.readOnly &&= g.readOnly;
-    if (p.requires?.guard) visit(p.requires.guard.procedure);
-  };
-  if (requires?.guard) visit(requires.guard.procedure);
-  for (; ; ) {
-    const before = hooks.size;
-    for (const [id, t] of Object.entries(plan.triggers).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0)) {
-      if (t.source.kind !== "lifecycle" || hooks.has(id)) continue;
-      const source = t.source;
-      if (!opaque && !inspected.writes.some((w) => w.schema === source.schema.toLowerCase() && source.on.some((on) => on.endsWith(`_${w.operation}`)))) continue;
-      hooks.add(id);
-      dependencies.push({ trigger: id, source });
-      visit(t.procedure);
-    }
-    if (hooks.size === before) break;
-  }
-  const related = (names) => {
-    const all = new Set(opaque ? Object.keys(plan.schemas) : names);
-    for (const name of all) {
-      const parent = plan.schemas[name]?.translates?.parent.toLowerCase();
-      if (parent) all.add(parent);
-    }
-    return [...all].sort();
-  };
-  return {
-    ...inspected,
-    schemas: related(inspected.schemas),
-    readSchemas: related(inspected.readSchemas),
-    opaque,
-    restrict: mergeRestrict(policies, true),
-    dependencies
-  };
-}
-var objectInput = { type: "object", properties: {} };
-var pathTemplate = (path) => path.replace(/\{([^}]+)\}/g, ":$1");
-var adminRoutes = [
-  "GET /me",
-  "GET /site",
-  "GET /collections",
-  "GET /views-manifest",
-  "GET /operations",
-  "GET /webmcp",
-  "POST /webmcp/:tool",
-  "GET /bootstrap",
-  "GET /views/:name/export",
-  "GET /views/:name",
-  "GET /view-batch",
-  "GET /developer/views/:name",
-  "POST /operations/:name",
-  "GET /developer-console",
-  "GET /collections/:name/statistics",
-  "GET /entries",
-  "GET /entries/export",
-  "GET /entries/:id",
-  "POST /entries",
-  "PATCH /entries/:id",
-  "POST /entries/:id/publish",
-  "POST /entries/:id/unpublish",
-  "POST /entries/:id/archive",
-  "DELETE /entries/:id",
-  "GET /site-settings",
-  "PATCH /site-settings",
-  "POST /media/uploads",
-  "POST /media/uploads/:groupId/commit",
-  "GET /media",
-  "GET /media/:id",
-  "PATCH /media/:id",
-  "DELETE /media/:id",
-  "GET /admin",
-  "GET /members",
-  "PATCH /admin/:id/role",
-  "POST /admin/invitations",
-  "DELETE /admin/invitations/:id"
-];
-function targetDefinitions(plan) {
-  const out = [];
-  const tools = [...mcpTools(plan, "public"), ...mcpTools(plan, "admin")];
-  for (const [kind, entries] of [["view", plan.views], ["procedure", plan.procedures]]) {
-    for (const [name, p] of Object.entries(entries).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0)) {
-      const view = kind === "view" ? plan.views[name] : void 0;
-      const proc = kind === "procedure" ? plan.procedures[name] : void 0;
-      const ir = view?.stmts ?? (proc && "sql" in proc.handler ? proc.handler.sql.stmts : void 0);
-      const inspected = inspectBehavior(plan, ir, !!proc && "ref" in proc.handler, p.requires, p.restrict);
-      const tool = tools.find((t) => t.kind === kind && t.source === name);
-      const title = resolveLocalizedText(p.title, "en", "en") ?? name;
-      const triggers = Object.entries(plan.triggers).filter(([, t]) => kind === "procedure" && t.procedure === name).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([id, t]) => ({ id, source: t.source }));
-      const surfaces = [.../* @__PURE__ */ new Set([
-        ...view ? [view.surface, "admin", ...view.surface === "public" ? ["rest"] : []] : [],
-        ...triggers.map((t) => t.source.kind === "mcp" ? t.source.surface : t.source.kind === "http" ? "rest" : t.source.kind)
-      ])].sort();
-      if (!surfaces.length) surfaces.push("internal");
-      out.push({
-        id: `${kind}:${name}`,
-        name: tool?.name ?? mcpToolNameSegment(name),
-        kind,
-        surface: view?.surface ?? (surfaces.includes("public") || surfaces.includes("rest") ? "public" : surfaces.includes("admin") ? "admin" : "internal"),
-        surfaces,
-        triggers,
-        title,
-        description: resolveLocalizedText(p.description, "en", "en") ?? title,
-        inputSchema: tool?.inputSchema ?? view?.input ?? proc?.input ?? objectInput,
-        annotations: tool?.annotations ?? {},
-        requires: p.requires,
-        restrict: inspected.restrict,
-        schemas: inspected.schemas,
-        readSchemas: inspected.readSchemas,
-        readOnly: !inspected.opaque && inspected.readOnly,
-        opaque: inspected.opaque,
-        trustedOnly: !!proc?.trustedOnly,
-        variants: [],
-        behavior: { declaration: p, dependencies: inspected.dependencies }
-      });
-    }
-  }
-  const addRoute = (id, dependencies, inputSchema = objectInput) => {
-    const admin = id.startsWith("admin:");
-    out.push({
-      id,
-      name: id.replace(/[^a-zA-Z0-9_-]/g, "_"),
-      title: id,
-      description: id,
-      kind: admin ? "admin" : "rest",
-      surface: admin ? "admin" : "public",
-      surfaces: [admin ? "admin" : "rest"],
-      triggers: dependencies.flatMap((d) => d.triggers),
-      inputSchema,
-      annotations: {},
-      requires: admin ? { auth: { all: ["ctx.admin"] } } : dependencies[0]?.requires,
-      restrict: mergeRestrict(dependencies.map((d) => d.restrict), false),
-      schemas: [...new Set(dependencies.flatMap((d) => d.schemas))].sort(),
-      readSchemas: [...new Set(dependencies.flatMap((d) => d.readSchemas))].sort(),
-      readOnly: dependencies.length > 0 && dependencies.every((d) => d.readOnly) && (!admin || id.startsWith("admin:GET ") || id === "admin:POST /operations/:name" || id === "admin:POST /webmcp/:tool"),
-      opaque: dependencies.some((d) => d.opaque),
-      trustedOnly: dependencies.some((d) => d.trustedOnly),
-      variants: dependencies,
-      behavior: dependencies.map((d) => ({ id: d.id, behavior: d.behavior, surfaces: d.surfaces, triggers: d.triggers, input: d.inputSchema, requires: d.requires, restrict: d.restrict, trustedOnly: d.trustedOnly }))
-    });
-  };
-  const declarations = [...out];
-  const adminOperations = new Set(mcpTools(plan, "admin").filter((t) => t.kind === "procedure").map((t) => `procedure:${t.source}`));
-  for (const d of declarations) if (d.kind === "view" && d.surfaces.includes("public")) addRoute(`rest:GET /api/views/${d.id.slice(5)}`, [d], d.inputSchema);
-  for (const [, t] of Object.entries(plan.triggers).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0)) if (t.source.kind === "http") {
-    const d = declarations.find((d2) => d2.id === `procedure:${t.procedure}`);
-    addRoute(`rest:${t.source.method} ${pathTemplate(t.source.path)}`, [d], d.inputSchema);
-  }
-  const generated = [];
-  for (const [schema, s] of Object.entries(plan.schemas).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0)) if (s.publishing) for (const [verb, from, to] of publishingTransitions) {
-    addRoute(`procedure:${s.name}.${verb}`, [], publishingInput);
-    const d = out.at(-1);
-    const inspected = inspectBehavior(plan, void 0, false, void 0, void 0, [{ schema, operation: verb === "publish" ? "publish" : "update" }]);
-    Object.assign(d, {
-      kind: "procedure",
-      name: mcpToolNameSegment(`${verb}_${s.name}`),
-      surface: "admin",
-      surfaces: ["admin"],
-      requires: { auth: { all: ["ctx.admin"] } },
-      schemas: [.../* @__PURE__ */ new Set([schema, ...inspected.schemas])].sort(),
-      readSchemas: [.../* @__PURE__ */ new Set([schema, ...inspected.readSchemas])].sort(),
-      opaque: inspected.opaque,
-      behavior: { schema, verb, from, to, dependencies: inspected.dependencies }
-    });
-    generated.push(d);
-  }
-  for (const tool of mediaDefinitions()) {
-    addRoute(`admin:tool:${tool.name}`, [], tool.inputSchema);
-    const d = out.at(-1);
-    Object.assign(d, { name: tool.name, readOnly: tool.annotations.readOnlyHint, opaque: !tool.annotations.readOnlyHint, annotations: tool.annotations, behavior: { tool, schemas: plan.schemas } });
-    generated.push(d);
-  }
-  for (const route of adminRoutes) {
-    const deps = route.includes("/views/:") || route === "GET /view-batch" ? declarations.filter((d2) => d2.kind === "view" && (route.includes("/developer/") || plan.views[d2.id.slice(5)]?.surface === "admin")) : route.includes("/operations/:") ? declarations.filter((d2) => adminOperations.has(d2.id)) : route === "POST /webmcp/:tool" ? declarations.filter((d2) => mcpTools(plan, "admin").some((t) => `${t.kind}:${t.source}` === d2.id)).concat(generated) : [];
-    const generic = route.includes("/entries") || route.includes("/statistics") || route === "GET /bootstrap";
-    addRoute(`admin:${route}`, deps, deps.length && route !== "GET /view-batch" ? { ...objectInput, anyOf: deps.map((d2) => ({ type: "object", properties: { [route.includes("/webmcp/") ? "tool" : "name"]: { type: "string", const: route.includes("/webmcp/") ? d2.name : d2.id.slice(d2.kind === "view" ? 5 : 10) } } })) } : objectInput);
-    const d = out.at(-1);
-    if (generic) {
-      const operation = route === "POST /entries" ? "create" : route === "DELETE /entries/:id" ? "delete" : route.startsWith("GET ") ? void 0 : route.endsWith("/publish") ? "publish" : "update";
-      const inspected = inspectBehavior(plan, void 0, false, void 0, void 0, operation ? Object.keys(plan.schemas).map((schema) => ({ schema, operation })) : []);
-      d.schemas = Object.keys(plan.schemas).sort();
-      d.readSchemas = d.schemas;
-      d.opaque = inspected.opaque;
-      d.behavior = { schemas: plan.schemas, dependencies: inspected.dependencies };
-    }
-  }
-  return [...new Map(out.map((d) => [d.id, d])).values()].sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
-}
-
-// src/domain/describe/target-hash.ts
-async function hash(value) {
-  const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(canonical(value)));
-  return [...new Uint8Array(digest)].map((b) => b.toString(16).padStart(2, "0")).join("");
-}
-function hashDefinition(plan, d) {
-  return hash({
-    id: d.id,
-    surfaces: d.surfaces,
-    triggers: d.triggers,
-    behavior: d.behavior,
-    input: d.inputSchema,
-    requires: d.requires,
-    restrict: d.restrict,
-    dialect: plan.dialect,
-    schemas: Object.fromEntries(d.schemas.map((name) => [name, plan.schemas[name]])),
-    userFields: plan.access?.userFields,
-    readOnly: d.readOnly,
-    opaque: d.opaque,
-    trustedOnly: d.trustedOnly
-  });
-}
-async function targetHash(plan, targetId) {
-  const target = targetDefinitions(plan).find((d) => d.id === targetId);
-  if (!target) throw new TypeError(`Unknown target '${targetId}'.`);
-  return hashDefinition(plan, target);
-}
-
-export {
-  canonical,
-  targetDefinitions,
-  hash,
-  hashDefinition,
-  targetHash
-};

package/docs/skills/develop/mcp-app.md

@@ -1,39 +0,0 @@
-# Recipe: an MCP App for members
-
-## Native applications
-
-Read the installed MCP App contract. The SDK's generic hook attaches only the resources the app selects;
-only selected modules enter the service.
-
-```ts
-import type { McpApps } from '@aotter/mantle/mcp';
-import { mcp } from '../generated/mcp.js';
-const memberApp: McpApps = { resources: [{
-  uri: 'ui://shop/my-orders',
-  name: 'my-orders-app',
-  renders: ['my_orders'], // the tool for the declared public View my-orders
-  html: async () => (await import('./member-app.js')).memberHtml,
-}] };
-const tools = mcp({ db, caller, handlers, apps: { public: memberApp } });
-```
-
-Each endpoint accepts one contributor or an array. The separate
-`@aotter/mantle-admin` package contributes its admin App through this same
-`apps.admin` hook; it owns `ui://mantle-admin/…`. App resources use their own
-`ui://<app>/…` namespace. Duplicate resource URI/name, conflicting `renders`,
-or `renders`/`appOnly` naming an unavailable endpoint tool (or a Procedure for
-`appOnly`) fail when `mcp(...)` is built; with a request-bound tool table, the
-tool names are checked on the first matching request. Only clients that
-declare no MCP Apps support see no UI resources; a request that advertises no
-capabilities at all is treated as supported.
-
-Use `renders` for a declared tool; `appOnly` optionally hides it from non-UI
-clients. Import HTML lazily; it carries no secrets or caller data. Tool results
-use the caller's SQL policy, and an App cannot authorize a hidden admin tool.
-Generic interaction components and controllers remain in `@aotter/mantle-ui`;
-Admin-specific controllers/catalogues belong to `@aotter/mantle-admin`.
-
-Verify tools/list metadata, resources/read, actual tool calls and a host-rendered
-member App. Test anonymous/member isolation and resource conflicts. Never retry
-unknown writes blindly; retain OCC and re-read state after an uncertain outcome.
-Commit generated output and run generation with `--check` before deployment.

package/skills/mantle/references/local-testing.md

@@ -1,15 +0,0 @@
-# Local HTTP acceptance
-
-
-Generation with `--check` and typechecking prove compilation, not handler execution. Before reporting local readiness or deploying, run the application's existing dev command with isolated local data and a console/test email sender. Use a small application-owned Node `assert` + `fetch` script; no browser, deployment or helper server runner is required.
-
-Better Auth limits each email-OTP path to 3 requests/minute per IP; `authHardening` stores rate limits in the database. Local tests signing in several users should send a distinct `cf-connecting-ip` header per user (with that header configured in `ipAddressHeaders`), or wait out the window. With the console sender, the OTP appears in the Wrangler log.
-
-- Exercise actual HTTP Triggers for every custom Procedure handler: valid input/output, invalid input, anonymous refusal on protected operations, authorized synthetic caller and expected stored result. A status below 500 alone is not success; assert the expected status and JSON envelope/body. Use only the generated contract's routes, inputs and permissions.
-- For an app-owned `fetch`, exercise its real public routes, not just dist files. Assert HTML content type, visible content and metadata/canonical/JSON-LD with no JavaScript execution, sitemap, robots and an unknown URL returning 404. Create a local synthetic draft and assert it is hidden anonymously; publish, edit and delete it through authorized operations and check the page and sitemap after each change. Reuse the application's existing smoke-test pattern and clean up test rows/server in `finally`.
-- If the app serves Admin, run `npm run build` and then `node --test generated/admin-mcp-app.check.mjs` (the examples name it `npm test`): the generated `generated/admin-mcp-app.check.mjs` loads the Admin MCP App in an MCP host and fails on a network request, console error or exception. It needs `playwright-core` (a devDependency) and Chrome (`npx playwright-core install chromium` or `MANTLE_TEST_CHROMIUM`); with no browser it fails, so report it as blocked rather than skipped. See `docs/handbook/guides/mcp-apps.md`.
-- Keep caller authority explicit: use supplied `resolveCaller` and caller-scoped Store/Procedure APIs from the installed service-entry docs. Use the actual local host capabilities; local tests do not prove remote identity/provider wiring.
-- Account for each declared interface separately: verified with the command/identity/result, intentionally not exposed, or deferred/unverified with a reason. Generation proves declaration and artifacts, not route mounting. An early Admin preview or a WebMCP-only application may defer remote MCP; preserve that pending item in the application's existing README, handoff or test report, without a new status/configuration format.
-- For selected remote MCP, use the installed `docs/examples/app-shell/smoke-kit.mjs` `assertMcpDiscovery(endpoint, { tools, headers })` in the application's smoke scenario. Derive `tools` from the generated `mcp.ts` exports, or the pure static `developerConsole.interfaces.callable` in generated `admin-descriptors.ts`; filter to the selected surface and explicitly select the expected permitted subset when application authorization narrows it. Include app-composed tools when present. Do not count `describe.targets` or reconstruct authorization rules in the harness. Assert initialized discovery and all `tools/list` pages; a 404, HTML 200, protocol error or missing expected tools must fail. Keep anonymous/member denial assertions separate. Discovery never needs a business-write `tools/call`.
-- Supply test credentials from the application's normal authorized sign-in/test setup (the smoke kit's console OTP sign-in is valid). The discovery assertion only receives credentials: it must not acquire credentials itself, scrape other sessions or manufacture authority. Report local cookie-session discovery, OAuth Bearer/client integration and browser WebMCP as separate evidence. Cookie or WebMCP success does not prove remote OAuth/ChatGPT wiring; missing credentials leave that case unverified, not passed. Do not enable remote routes or OAuth merely to make acceptance pass.
-- Record commands and passed/failed/blocked cases for the exact commit. Fix failures before source admission; rerun relevant checks after changing source. Packing does not run these checks and an agent's checklist is not server build attestation.

package/skills/mantle/references/web.md

@@ -1,41 +0,0 @@
-# Generated public websites
-
-Use this flow only when the installed package README documents concrete native
-queries and generated `web.ts`.
-Earlier Core versions use their own installed handbook. Read the installed
-`docs/handbook/reference/surface.md` and `docs/examples/generated-web/README.md` under `node_modules/@aotter/mantle/` before writing
-routes; the installed version is authoritative.
-
-Mount `web()` when the application serves public HTML and needs `llms.txt`, a
-sitemap or Markdown alternates. Import the generated `web.ts`; pass the native
-`db`, a verified Caller (or the app's resolver), the configured public `origin`,
-`title`, `description` and `pages`. Mount generated `rest.ts` for public View and
-HTTP Trigger APIs. Neither module renders the application's HTML.
-
-Each page template's `{parameter}` names exactly match its public View inputs;
-both its View and list View return these parameters. A list View accepts empty
-input. `markdown` names a textual column in the detail View. Supply the same
-SQL-visible data to the HTML renderer through generated Views or the typed Store.
-Never add a frontend status filter: generated SQL owns publishing, scope and TTL.
-
-In the Fetch entry, return a handled REST/web response, then render HTML for the
-remaining page routes. Insert `await site.head(request, env)` inside `<head>`:
-it supplies canonical and Markdown alternate tags from the current View row,
-using the configured origin rather than the request host. Escape all other
-application text. An unavailable page needs an application-owned 404; an empty
-`head()` result alone does not render that response.
-
-Verify locally before deploying:
-
-1. Generate, typecheck, implement every listed ref handler and typecheck again.
-2. Walk the public list's complete cursor chain. Its rows equal the `llms.txt`
-   entries and sitemap detail URLs below the documented index caps.
-3. Request each rendered page and assert its canonical uses the configured
-   origin and its `.md` alternate returns current Markdown. Request hidden
-   drafts, expired/scoped-out rows and malformed paths; they must not leak data.
-4. Check GET/HEAD, 404 `no-store` and escaped HTML. Importing no web entry should
-   keep web rendering code out of the application's bundle.
-
-The current caps are 5,000 scanned rows/10 queries/1 MiB for `llms.txt`, and
-50,000 rows/100 queries/50 MiB for sitemap. Translation-aware indexes and
-hreflang are a documented follow-up; do not claim them from `locales[0]`.

package/skills/mantle/references/website.md

@@ -1,49 +0,0 @@
-# Complete website defaults
-
-These are default generation and acceptance requirements for a complete website,
-unless the user explicitly changes the scope. They do not add Manifest keys or
-change Core's optional composition. Read the installed version's docs and the
-selected host's frontend kit before choosing APIs. Native applications use
-their installed `docs/handbook/guides/native-admin.md` and the
-[web contract](web.md).
-
-- For self-hosted applications, mount the selected Admin API and serve the
-  separate Admin package's assets with its shell/CSP contract. The application
-  owns auth, OTP delivery and verified Caller wiring; use a console/test sender
-  locally and configure production email for deployment. If a host already
-  supplies identity/Admin, reuse its explicit contract and reserved routes.
-  Add visitor sign-in where needed. Backend permissions enforce roles and data
-  access; host membership alone is not application admin authority.
-- Integrate image selection/upload into content editing through the existing
-  Admin media library and the application's selected storage. Follow the pinned Core upload/PUT/commit
-  contract and `x-mantle-ref: media_assets` plus `x-mcp-hint: media-image`; store committed asset IDs, resolve permanent variants in the frontend, never use an ID as an image URL. The application's `/mcp/admin` supplies `get_media_upload_policy` → `create_media_upload` → direct HTTP PUT → `commit_media_upload` when its shared media adapter is wired. Follow the installed media authentication contract; host project credentials are not application credentials. Upload capability URLs are temporary,
-  not committed public images; anonymous visitors must not gain admin media access.
-- Generate an accessible, responsive public frontend by reading the installed
-  generated `web.ts` and REST contracts; browser code on static hosts uses
-  same-origin fetch, not a server surface imported into the browser. Do not install the historical standalone
-  `@aotter/mantle-web` or claim Core supplies an HTML renderer. The application-owned Fetch entry renders HTML; follow the selected host's static/template restrictions.
-- Public content follows the installed `docs/handbook/guides/public-pages.md`
-  (the one list of head tags, JSON-LD, languages, Markdown, sitemap, robots and
-  `llms.txt`). For public content on static hosts disable SPA fallback and check unknown URLs
-  return 404. Follow the selected host's permanent origin contract. Missing
-  final origin blocks origin-dependent checks.
-  Structured data must match visible content; do not fabricate facts or promise
-  ranking or AI citation.
-- Verify that content publication, edits and deletion update the crawlable page
-  and sitemap. If static generation requires a rebuild, explain the publishing
-  dependency; a dynamic blog is blocked until that path exists. Do not silently
-  substitute build-time sample content for live tenant content.
-
-Follow the [local HTTP acceptance](local-testing.md) before reporting local
-readiness: inspect HTML without JavaScript, check metadata/sitemap and anonymous
-draft/permission refusal, and exercise OTP and editing with isolated synthetic
-accounts. Local readiness does not require publication, a hosted tenant or a
-candidate preview. Report production email, public origin and real object-store
-upload/commit checks separately when local capabilities cannot exercise them.
-
-For an explicitly requested deployment, use the selected host's native workflow
-and any preview it provides. Verify disabled preview capabilities on an already
-authorized live target; synthetic writes and cleanup stay within that scope.
-Pending production checks block a production-readiness claim, not an otherwise
-passing local-development handoff. Preserve preview isolation and permissions;
-report passed, failed and blocked checks for each environment separately.