@spacefast/common 0.2.1 → 0.4.1

package/dist/contracts/content-model-emit.js

@@ -0,0 +1,306 @@
+import { canonicalJson } from "../utils/canonical-json.js";
+import { contentContractSha256, } from "./content-contract-verification.js";
+import { contentModelSdkDescriptors } from "./content-model-sdk.js";
+import { CONTENT_MODEL_ARTIFACT_FORMATS, CONTENT_MODEL_FORMAT, CONTENT_MODEL_VERSION, compiledContentModelV1Schema, contentExecutableSetV1Schema, contentModelFieldSchema, contentModelReleaseV1Schema, contentRouteContributionSetV1Schema, } from "./content-model.js";
+import { compiledContentModelArtifactsV1Schema, contentModelRequirementsV1Schema, } from "./runtime-components.js";
+/**
+ * The fields WordPress gives every site whether an author mentions them or not.
+ * A `posts` collection that never declared a title still has one, so the model
+ * declares it too rather than shipping an editor with no title box. The
+ * author's own field of the same name wins.
+ */
+const NATIVE_POST_FIELD_NAMES = new Set(["title", "content", "excerpt", "featured_media"]);
+const NATIVE_FIELDS = {
+    posts: [
+        {
+            id: "posts-title",
+            name: "title",
+            label: "Title",
+            required: true,
+            value: { kind: "text", multiline: false, maxLength: 500 },
+        },
+        {
+            id: "posts-content",
+            name: "content",
+            label: "Content",
+            required: false,
+            value: { kind: "blocks", allowed: "any" },
+        },
+    ],
+    pages: [
+        {
+            id: "pages-title",
+            name: "title",
+            label: "Title",
+            required: true,
+            value: { kind: "text", multiline: false, maxLength: 500 },
+        },
+        {
+            id: "pages-content",
+            name: "content",
+            label: "Content",
+            required: false,
+            value: { kind: "blocks", allowed: "any" },
+        },
+    ],
+    media: [
+        {
+            id: "media-alt",
+            name: "alt",
+            label: "Alternative text",
+            required: false,
+            value: { kind: "text", multiline: false, maxLength: 2_000 },
+        },
+    ],
+};
+const NATIVE_LABELS = {
+    posts: "Posts",
+    pages: "Pages",
+    media: "Media",
+};
+/**
+ * The JSON Schema for one field, deliberately the same shape the control
+ * plane's PHP generator gives `register_post_meta`'s `show_in_rest`. A model
+ * whose declared contract disagreed with what WordPress serves would be a
+ * contract in name only.
+ */
+function fieldJsonSchema(field) {
+    const value = field.value;
+    switch (value.kind) {
+        case "number":
+            return { type: "number" };
+        case "boolean":
+            return { type: "boolean" };
+        case "media":
+        case "reference":
+            return value.multiple ? { type: "array", items: { type: "integer" } } : { type: "integer" };
+        case "enum":
+            return value.multiple
+                ? { type: "array", items: { type: "string", enum: [...value.values] } }
+                : { type: "string", enum: [...value.values] };
+        case "text":
+            return value.maxLength === null
+                ? { type: "string" }
+                : { type: "string", maxLength: value.maxLength };
+        case "datetime":
+            return { type: "string", format: "date-time" };
+        case "blocks":
+            // HTML, not block markup. A `blocks` field is stored as WordPress blocks
+            // and exposed as HTML in both directions, so this is what the contract
+            // has to say a customer will receive and may send. Declaring a bare
+            // string here is what let `<!-- wp: -->` look like a conforming value.
+            return {
+                type: "string",
+                contentMediaType: "text/html",
+                description: "HTML. WordPress block markup is never exposed or accepted here.",
+            };
+    }
+}
+function resourceJsonSchema(resource) {
+    const properties = {};
+    for (const field of resource.fields) {
+        properties[field.name] = fieldJsonSchema(field);
+    }
+    return {
+        $schema: "https://json-schema.org/draft/2020-12/schema",
+        type: "object",
+        title: resource.label,
+        properties,
+        required: resource.fields.filter((field) => field.required).map((field) => field.name),
+        additionalProperties: false,
+    };
+}
+const EMPTY_PROPS_SCHEMA = {
+    $schema: "https://json-schema.org/draft/2020-12/schema",
+    type: "object",
+    properties: {},
+    required: [],
+    additionalProperties: false,
+};
+/**
+ * Merges an adopted native's declared fields over the ones WordPress always
+ * has. A native nobody adopted keeps WordPress's own default of public reads;
+ * an adopted one takes the author's read policy.
+ */
+function nativeResource(kind, adopted) {
+    const declared = adopted?.fields ?? [];
+    const declaredNames = new Set(declared.map((field) => field.name));
+    const inherited = NATIVE_FIELDS[kind].filter((field) => !declaredNames.has(field.name));
+    return {
+        id: kind,
+        name: kind,
+        label: adopted?.label ?? NATIVE_LABELS[kind],
+        kind,
+        publicRead: adopted?.publicRead ?? true,
+        fields: [...inherited, ...declared],
+    };
+}
+/**
+ * The runtime components this model needs, derived from what it actually
+ * declares. A model that never asks for a custom field must not demand the
+ * plugin that renders one.
+ */
+function requiredCapabilities(resources, syncBindings) {
+    const capabilities = [
+        "wordpress.core",
+        "wordpress.blocks",
+        "wordpress.media",
+        "wordpress.content-kernel",
+    ];
+    // Exactly the condition the PHP generator builds an SCF field group for: a
+    // collection resource carrying at least one field WordPress does not already
+    // store on the post row.
+    const usesCustomFields = resources.some((resource) => resource.kind === "collection" &&
+        resource.fields.some((field) => !NATIVE_POST_FIELD_NAMES.has(field.name)));
+    if (usesCustomFields)
+        capabilities.push("wordpress.scf");
+    if (syncBindings.length > 0)
+        capabilities.push("source.sync");
+    return capabilities;
+}
+function artifactRef(format, inputDigest, sha256, 
+// The same input `contentContractSha256` digests: a parsed release carries
+// optional properties, so the artifact type has to admit an absent one.
+artifact) {
+    return {
+        format,
+        version: 1,
+        inputDigest,
+        sha256,
+        bytes: new TextEncoder().encode(canonicalJson(artifact)).byteLength,
+        mediaType: "application/json",
+    };
+}
+const PLACEHOLDER_REVISION = `sha256:${"0".repeat(64)}`;
+/**
+ * Lowers declared content into the compiled model.
+ *
+ * The revision is digested from the *parsed* release with its own revision
+ * removed, never from the draft that went in. The schema trims labels and
+ * applies defaults, so digesting the draft would produce a revision that
+ * `verifyContentModelReleaseV1` recomputes differently and rejects.
+ *
+ * No Abilities are emitted. This model declares content and nothing that runs,
+ * so there are no executables, no routes, and an SDK whose operations are
+ * empty — inventing a query here would mean inventing the QuickJS body behind
+ * it. The content is still reachable: the kernel registers the post types,
+ * meta, and taxonomy terms, and WordPress's own REST surface serves them.
+ */
+export async function emitContentModelArtifacts(input) {
+    const syncBindings = input.syncBindings ?? [];
+    const materializations = input.materializations ?? [];
+    const pages = input.pages ?? [];
+    const adopted = new Map(input.resources
+        .filter((resource) => resource.kind !== "collection")
+        .map((resource) => [resource.kind, resource]));
+    const resources = [
+        nativeResource("posts", adopted.get("posts")),
+        nativeResource("pages", adopted.get("pages")),
+        nativeResource("media", adopted.get("media")),
+        ...input.resources.filter((resource) => resource.kind === "collection"),
+    ];
+    const resourceSchemas = await Promise.all(resources.map(async (resource) => {
+        const schema = resourceJsonSchema(resource);
+        return {
+            id: `content.${resource.id}.item`,
+            sha256: await contentContractSha256(schema),
+            schema,
+        };
+    }));
+    // Every page shares one empty props schema: a page compiled from a component
+    // path declares no props yet, and emitting a distinct identical schema per
+    // page would bloat the release for nothing.
+    const pageSchemas = pages.length === 0
+        ? []
+        : [
+            {
+                id: "content.page.props",
+                sha256: await contentContractSha256(EMPTY_PROPS_SCHEMA),
+                schema: EMPTY_PROPS_SCHEMA,
+            },
+        ];
+    const pagePropsRef = pageSchemas[0] ?? null;
+    if (pages.length > 0 && pagePropsRef === null) {
+        throw new TypeError("A content model with pages must carry the shared page props schema.");
+    }
+    const draftInput = {
+        format: CONTENT_MODEL_FORMAT,
+        version: CONTENT_MODEL_VERSION,
+        revision: PLACEHOLDER_REVISION,
+        schemas: [...resourceSchemas, ...pageSchemas],
+        wordpress: {
+            format: "spacefast.wordpress-content-model",
+            version: 1,
+            resources: resources.map((resource) => ({
+                id: resource.id,
+                name: resource.name,
+                label: resource.label,
+                kind: resource.kind,
+                publicRead: resource.publicRead,
+                fields: resource.fields.map((field) => ({ ...field })),
+            })),
+        },
+        tables: [],
+        abilities: [],
+        pages: pages.map((page) => ({
+            id: page.id,
+            sourceKey: page.sourceKey,
+            path: page.path,
+            title: page.title,
+            blockName: "zero/component",
+            componentId: page.componentId,
+            props: { id: pagePropsRef?.id, sha256: pagePropsRef?.sha256 },
+        })),
+        hooks: [],
+        syncBindings: syncBindings.map((binding) => ({ ...binding })),
+        materializations: materializations.map((materialization) => ({ ...materialization })),
+    };
+    const draft = contentModelReleaseV1Schema.parse(draftInput);
+    const { revision: _placeholder, ...meaning } = draft;
+    const revision = await contentContractSha256(meaning);
+    const contentModel = contentModelReleaseV1Schema.parse({ ...meaning, revision });
+    const executables = contentExecutableSetV1Schema.parse({
+        format: CONTENT_MODEL_ARTIFACT_FORMATS.executables,
+        version: 1,
+        inputDigest: revision,
+        executables: [],
+    });
+    const sdk = contentModelSdkDescriptors(contentModel);
+    const routes = contentRouteContributionSetV1Schema.parse({
+        format: CONTENT_MODEL_ARTIFACT_FORMATS.routes,
+        version: 1,
+        inputDigest: revision,
+        routes: [],
+    });
+    const requirements = contentModelRequirementsV1Schema.parse({
+        format: CONTENT_MODEL_ARTIFACT_FORMATS.requirements,
+        version: 1,
+        inputDigest: revision,
+        wordpressAbi: 1,
+        capabilities: requiredCapabilities(resources, syncBindings),
+    });
+    const [contentModelSha, executablesSha, sdkSha, routesSha, requirementsSha] = await Promise.all([
+        contentContractSha256(contentModel),
+        contentContractSha256(executables),
+        contentContractSha256(sdk),
+        contentContractSha256(routes),
+        contentContractSha256(requirements),
+    ]);
+    const compiled = compiledContentModelV1Schema.parse({
+        format: "spacefast.compiled-content-model",
+        version: 1,
+        model: artifactRef(CONTENT_MODEL_ARTIFACT_FORMATS.model, input.sourceDigest, contentModelSha, contentModel),
+        executables: artifactRef(CONTENT_MODEL_ARTIFACT_FORMATS.executables, revision, executablesSha, executables),
+        sdk: artifactRef(CONTENT_MODEL_ARTIFACT_FORMATS.sdk, revision, sdkSha, sdk),
+        routes: artifactRef(CONTENT_MODEL_ARTIFACT_FORMATS.routes, revision, routesSha, routes),
+        requirements: artifactRef(CONTENT_MODEL_ARTIFACT_FORMATS.requirements, revision, requirementsSha, requirements),
+    });
+    return compiledContentModelArtifactsV1Schema.parse({
+        compiled,
+        model: contentModel,
+        executables,
+        sdk,
+        routes,
+        requirements,
+    });
+}

package/dist/contracts/content-model-sdk.d.ts

@@ -0,0 +1,101 @@
+import { type ContentCacheProfileV1, type ContentModelJsonValue, type ContentModelReleaseV1, type ContentSdkDescriptorSetV1 } from "./content-model.js";
+/**
+ * The content model SDK: the typed surface a compiled ContentModelRelease offers its
+ * callers.
+ *
+ * Two derivations, one input. `contentModelSdkDescriptors` lowers a
+ * ContentModelRelease into the SDK descriptor artifact the compiled bundle carries,
+ * and `contentModelSdkModule` lowers the same release into a self-contained
+ * TypeScript module an app or an agent can drop into its own project. Both are
+ * pure functions of the release, so the SDK is never a separate thing to keep
+ * in step with the content model — it is the content model, spelled for a caller.
+ *
+ * Dispatch is not here and never will be: a compiled Ability is published
+ * through the WordPress Abilities API under `contentAbilityWordPressName`, and
+ * that registry is the one dispatcher. `createContentModelClient` is the thin
+ * typed seam over whichever transport reaches it — REST, MCP, or an in-process
+ * call.
+ */
+/**
+ * Derives the SDK descriptor artifact from a ContentModelRelease.
+ *
+ * `invalidates` is the whole reason this is a derivation rather than a
+ * declaration. A write Ability invalidates exactly the read Abilities that read
+ * a resource it writes, so a cached read cannot outlive the write that changed
+ * it. Nothing upstream is trusted to compute that graph: the release names the
+ * reads and the writes, and the edges follow.
+ */
+export declare function contentModelSdkDescriptors(contentModel: ContentModelReleaseV1): ContentSdkDescriptorSetV1;
+/**
+ * What a caller must hold to run an Ability, in the vocabulary the catalog uses.
+ *
+ * Structurally the same as `SpaceZeroAbilityRequirement`; spelled here rather
+ * than imported so this module stays the self-contained one it prints from.
+ */
+export type ContentModelAbilityRequirement = Readonly<{
+    kind: "wordpress";
+    capability: string;
+}> | Readonly<{
+    kind: "grant";
+    capabilities: readonly string[];
+}>;
+export type ContentModelAbilityDescriptor = Readonly<{
+    /** The name the WordPress Abilities API publishes this Ability under. */
+    name: string;
+    kind: "query" | "mutation" | "endpoint";
+    mode: "read" | "write";
+    cache: ContentCacheProfileV1;
+    invalidates: readonly string[];
+    /**
+     * What a caller must hold, when the descriptor's source knows.
+     *
+     * A transport that cannot supply a credential — a browser on a public content
+     * page — refuses a call that needs one instead of shipping it to a 403. Absent
+     * means the descriptor's source did not state a requirement, which is not the
+     * same as "requires nothing" and is deliberately not read as a grant.
+     */
+    requires?: ContentModelAbilityRequirement;
+}>;
+export type ContentModelAbilityType = Readonly<{
+    input: ContentModelJsonValue;
+    output: ContentModelJsonValue;
+}>;
+export type ContentModelAbilityTypes = Readonly<Record<string, ContentModelAbilityType>>;
+export type ContentModelAbilityCall = Readonly<{
+    abilityId: string;
+    ability: ContentModelAbilityDescriptor;
+    input: ContentModelJsonValue;
+}>;
+/** Whatever reaches the Abilities API — REST, MCP, or an in-process call. */
+export type ContentModelAbilityDispatch = (call: ContentModelAbilityCall) => Promise<ContentModelJsonValue>;
+export type ContentModelClient<TAbilities extends ContentModelAbilityTypes> = Readonly<{
+    abilities: Readonly<Record<keyof TAbilities & string, ContentModelAbilityDescriptor>>;
+    call<TId extends keyof TAbilities & string>(id: TId, input: TAbilities[TId]["input"]): Promise<TAbilities[TId]["output"]>;
+}>;
+/**
+ * Binds a generated module's ability table to a dispatcher. The client resolves
+ * a content model id to the WordPress Ability name and hands the call on; it decides
+ * nothing about admission, caching, or execution.
+ */
+export declare function createContentModelClient<TAbilities extends ContentModelAbilityTypes>(options: {
+    abilities: Readonly<Record<keyof TAbilities & string, ContentModelAbilityDescriptor>>;
+    dispatch: ContentModelAbilityDispatch;
+}): ContentModelClient<TAbilities>;
+/**
+ * Prints one JSON Schema as a TypeScript type.
+ *
+ * Exported for the Ability catalog printer, which prints the same dialect for
+ * schemas that never came from a content model: the platform Ability sets
+ * declare theirs inline in the engine's PHP. One printer for both keeps a
+ * `zero-types` module from spelling the same shape two ways.
+ */
+export declare function printContentModelSchema(schema: ContentModelJsonValue): string;
+/**
+ * Emits the self-contained TypeScript module for a ContentModelRelease.
+ *
+ * No imports, by design: the output is meant to be written into someone else's
+ * project, where a dependency on `@spacefast/common` would be an imposition. Its
+ * banner names `createContentModelClient` without importing it — pair the two
+ * yourself when you want the typed call seam.
+ */
+export declare function contentModelSdkModule(contentModel: ContentModelReleaseV1): string;

package/dist/contracts/content-model-sdk.js

@@ -0,0 +1,232 @@
+import { z } from "zod";
+import { CONTENT_MODEL_ARTIFACT_FORMATS, contentAbilityTypeName, contentAbilityWordPressName, contentSdkDescriptorSetV1Schema, } from "./content-model.js";
+/**
+ * The content model SDK: the typed surface a compiled ContentModelRelease offers its
+ * callers.
+ *
+ * Two derivations, one input. `contentModelSdkDescriptors` lowers a
+ * ContentModelRelease into the SDK descriptor artifact the compiled bundle carries,
+ * and `contentModelSdkModule` lowers the same release into a self-contained
+ * TypeScript module an app or an agent can drop into its own project. Both are
+ * pure functions of the release, so the SDK is never a separate thing to keep
+ * in step with the content model — it is the content model, spelled for a caller.
+ *
+ * Dispatch is not here and never will be: a compiled Ability is published
+ * through the WordPress Abilities API under `contentAbilityWordPressName`, and
+ * that registry is the one dispatcher. `createContentModelClient` is the thin
+ * typed seam over whichever transport reaches it — REST, MCP, or an in-process
+ * call.
+ */
+/**
+ * Derives the SDK descriptor artifact from a ContentModelRelease.
+ *
+ * `invalidates` is the whole reason this is a derivation rather than a
+ * declaration. A write Ability invalidates exactly the read Abilities that read
+ * a resource it writes, so a cached read cannot outlive the write that changed
+ * it. Nothing upstream is trusted to compute that graph: the release names the
+ * reads and the writes, and the edges follow.
+ */
+export function contentModelSdkDescriptors(contentModel) {
+    const readers = contentModel.abilities.filter((ability) => ability.mode === "read");
+    return contentSdkDescriptorSetV1Schema.parse({
+        format: CONTENT_MODEL_ARTIFACT_FORMATS.sdk,
+        version: 1,
+        inputDigest: contentModel.revision,
+        operations: contentModel.abilities.map((ability) => ({
+            id: ability.id,
+            kind: ability.kind,
+            mode: ability.mode,
+            input: ability.input,
+            output: ability.output,
+            cache: ability.cache,
+            invalidates: ability.mode === "write"
+                ? readers
+                    .filter((reader) => reader.reads.some((resource) => ability.writes.includes(resource)))
+                    .map((reader) => reader.id)
+                : [],
+        })),
+        sync: contentModel.syncBindings.map((binding) => ({
+            id: binding.id,
+            resourceId: binding.resourceId,
+            source: binding.source,
+        })),
+    });
+}
+/**
+ * Binds a generated module's ability table to a dispatcher. The client resolves
+ * a content model id to the WordPress Ability name and hands the call on; it decides
+ * nothing about admission, caching, or execution.
+ */
+export function createContentModelClient(options) {
+    return {
+        abilities: options.abilities,
+        async call(id, input) {
+            const ability = options.abilities[id];
+            if (ability === undefined) {
+                throw new TypeError(`The generated content model SDK has no Ability named ${id}.`);
+            }
+            const output = await options.dispatch({ abilityId: id, ability, input });
+            // SAFETY: the Abilities API answers under the Ability's declared output
+            // schema, and the generated type is that schema's TypeScript spelling.
+            return output;
+        },
+    };
+}
+const contentModelLiteralSchema = z.union([z.string(), z.number(), z.boolean(), z.null()]);
+// The JSON Schema dialect a compiled content model actually writes. Anything outside
+// it parses as `undefined` and prints as `unknown` rather than as a guess: a
+// wrong type is worse than an honest absence of one.
+const contentModelJsonSchemaSchema = z.lazy(() => z
+    .object({
+    $ref: z.string().optional(),
+    $defs: z.record(z.string(), contentModelJsonSchemaSchema).optional(),
+    type: z.union([z.string(), z.array(z.string())]).optional(),
+    enum: z.array(contentModelLiteralSchema).optional(),
+    const: contentModelLiteralSchema.optional(),
+    properties: z.record(z.string(), contentModelJsonSchemaSchema).optional(),
+    required: z.array(z.string()).optional(),
+    additionalProperties: z.union([z.boolean(), contentModelJsonSchemaSchema]).optional(),
+    items: contentModelJsonSchemaSchema.optional(),
+    anyOf: z.array(contentModelJsonSchemaSchema).optional(),
+    oneOf: z.array(contentModelJsonSchemaSchema).optional(),
+})
+    .loose());
+const DEFINITION_POINTER_PREFIX = "#/$defs/";
+function propertyKey(name) {
+    return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(name) ? name : JSON.stringify(name);
+}
+function printObject(schema, definitions, visiting) {
+    const properties = Object.entries(schema.properties ?? {});
+    if (properties.length === 0) {
+        const additional = schema.additionalProperties;
+        if (additional === false) {
+            return "Readonly<Record<string, never>>";
+        }
+        const value = additional === undefined || additional === true
+            ? "unknown"
+            : printSchema(additional, definitions, visiting);
+        return `Readonly<Record<string, ${value}>>`;
+    }
+    const required = new Set(schema.required ?? []);
+    const members = properties.map(([name, property]) => {
+        const optional = required.has(name) ? "" : "?";
+        return `readonly ${propertyKey(name)}${optional}: ${printSchema(property, definitions, visiting)}`;
+    });
+    return `{ ${members.join("; ")} }`;
+}
+function printKeyword(keyword, schema, definitions, visiting) {
+    switch (keyword) {
+        case "object":
+            return printObject(schema, definitions, visiting);
+        case "array":
+            return schema.items === undefined
+                ? "unknown[]"
+                : `Array<${printSchema(schema.items, definitions, visiting)}>`;
+        case "string":
+            return "string";
+        case "integer":
+        case "number":
+            return "number";
+        case "boolean":
+            return "boolean";
+        case "null":
+            return "null";
+        default:
+            return "unknown";
+    }
+}
+function printSchema(schema, definitions, visiting) {
+    if (schema.$ref !== undefined) {
+        const name = schema.$ref.startsWith(DEFINITION_POINTER_PREFIX)
+            ? schema.$ref.slice(DEFINITION_POINTER_PREFIX.length)
+            : null;
+        const target = name === null ? undefined : definitions.get(name);
+        // A self-referential definition has no finite spelling here, and inventing
+        // a named alias for it would leak the content model's internal $defs into the
+        // SDK's surface. `unknown` is the honest stopping point.
+        if (name === null || target === undefined || visiting.has(name)) {
+            return "unknown";
+        }
+        return printSchema(target, definitions, new Set([...visiting, name]));
+    }
+    if (schema.const !== undefined) {
+        return JSON.stringify(schema.const);
+    }
+    if (schema.enum !== undefined && schema.enum.length > 0) {
+        return schema.enum.map((value) => JSON.stringify(value)).join(" | ");
+    }
+    const alternatives = schema.anyOf ?? schema.oneOf;
+    if (alternatives !== undefined && alternatives.length > 0) {
+        return alternatives
+            .map((alternative) => printSchema(alternative, definitions, visiting))
+            .join(" | ");
+    }
+    if (schema.type === undefined) {
+        return "unknown";
+    }
+    const keywords = Array.isArray(schema.type) ? schema.type : [schema.type];
+    return keywords
+        .map((keyword) => printKeyword(keyword, schema, definitions, visiting))
+        .join(" | ");
+}
+/**
+ * Prints one JSON Schema as a TypeScript type.
+ *
+ * Exported for the Ability catalog printer, which prints the same dialect for
+ * schemas that never came from a content model: the platform Ability sets
+ * declare theirs inline in the engine's PHP. One printer for both keeps a
+ * `zero-types` module from spelling the same shape two ways.
+ */
+export function printContentModelSchema(schema) {
+    const parsed = contentModelJsonSchemaSchema.safeParse(schema);
+    if (!parsed.success) {
+        return "unknown";
+    }
+    const definitions = new Map(Object.entries(parsed.data.$defs ?? {}));
+    return printSchema(parsed.data, definitions, new Set());
+}
+/**
+ * Emits the self-contained TypeScript module for a ContentModelRelease.
+ *
+ * No imports, by design: the output is meant to be written into someone else's
+ * project, where a dependency on `@spacefast/common` would be an imposition. Its
+ * banner names `createContentModelClient` without importing it — pair the two
+ * yourself when you want the typed call seam.
+ */
+export function contentModelSdkModule(contentModel) {
+    const descriptors = contentModelSdkDescriptors(contentModel);
+    const schemas = new Map(contentModel.schemas.map((schema) => [schema.id, schema.schema]));
+    const printRef = (id) => {
+        const schema = schemas.get(id);
+        return schema === undefined ? "unknown" : printContentModelSchema(schema);
+    };
+    const entries = descriptors.operations.map((operation) => ({
+        id: operation.id,
+        typeName: contentAbilityTypeName(operation.id),
+        input: printRef(operation.input.id),
+        output: printRef(operation.output.id),
+        descriptor: {
+            name: contentAbilityWordPressName(operation.id),
+            kind: operation.kind,
+            mode: operation.mode,
+            cache: operation.cache,
+            invalidates: operation.invalidates,
+        },
+    }));
+    const lines = [
+        "// Generated from a Spacefast ContentModelRelease. Do not edit.",
+        "//",
+        "// Every Ability below is published by the WordPress Abilities API under the",
+        "// `name` in `contentModelAbilities`. Hand this table to",
+        "// `createContentModelClient` from `@spacefast/common/contracts/content-model-sdk`",
+        "// for a typed `call`, or address the names directly over REST or MCP.",
+        "",
+        `export const contentModelRevision = ${JSON.stringify(contentModel.revision)};`,
+        "",
+    ];
+    for (const entry of entries) {
+        lines.push(`/** Input for the \`${entry.id}\` Ability. */`, `export type ${entry.typeName}Input = ${entry.input};`, "", `/** Output of the \`${entry.id}\` Ability. */`, `export type ${entry.typeName}Output = ${entry.output};`, "");
+    }
+    lines.push("export type ContentModelAbilityTypes = {", ...entries.map((entry) => `  ${JSON.stringify(entry.id)}: { input: ${entry.typeName}Input; output: ${entry.typeName}Output };`), "};", "", "export const contentModelAbilities = {", ...entries.map((entry) => `  ${JSON.stringify(entry.id)}: ${JSON.stringify(entry.descriptor)},`), "} as const;", "", `export const contentModelSyncBindings = ${JSON.stringify(descriptors.sync)} as const;`, "");
+    return lines.join("\n");
+}