@spacefast/common 0.2.2 → 0.4.1

package/dist/contracts/content-contract-verification.d.ts

@@ -1,35 +1,35 @@
 import { z } from "zod";
 import { applicationJournalDeliveryClaimV1Schema, applicationJournalDeliveryReceiptV1Schema, applicationJournalEntryV1Schema, type ApplicationJournalDeliveryClaimV1, type ApplicationJournalDeliveryReceiptV1, type ApplicationJournalEntryV1 } from "./application-journal.js";
-import { contentProgramReleaseV1Schema, type ContentProgramReleaseV1, type ContentProgramSha256 } from "./content-program.js";
-import { contentMarkdownConflictProblemSchema, syncReconciliationExchangeV1Schema, syncSourceAcknowledgementV1Schema, syncLedgerV1Schema, type ContentMarkdownConflictProblem, type SyncReconciliationExchangeV1, type SyncSourceAcknowledgementV1, type SyncLedgerV1 } from "./content-sync.js";
+import { contentModelReleaseV1Schema, type ContentModelReleaseV1, type ContentModelSha256 } from "./content-model.js";
+import { contentSyncConflictProblemSchema, syncReconciliationExchangeV1Schema, syncSourceAcknowledgementV1Schema, syncLedgerV1Schema, type ContentSyncConflictProblem, type SyncReconciliationExchangeV1, type SyncSourceAcknowledgementV1, type SyncLedgerV1 } from "./content-sync.js";
 import { frameLaunchTicketClaimsV1Schema, frameSessionClaimsV1Schema, type FrameLaunchTicketClaimsV1, type FrameSessionClaimsV1 } from "./frame-session.js";
 import { principalAssertionV1Schema, type PrincipalAssertionV1 } from "./principal-assertion.js";
 import { routeInventoryV1Schema, spaceRouteSnapshotV1Schema, type RouteInventoryV1, type SpaceRouteSnapshotV1 } from "./route-inventory.js";
-import { programRequirementsV1Schema, runtimeComponentInventoryV1Schema, runtimeComponentPlacementReceiptV1Schema, runtimeComponentPlacementTargetV1Schema, type RuntimeComponentPlacementReceiptV1, type RuntimeComponentInventoryV1, type RuntimeComponentPlacementTargetV1 } from "./runtime-components.js";
+import { contentModelRequirementsV1Schema, runtimeComponentInventoryV1Schema, runtimeComponentPlacementReceiptV1Schema, runtimeComponentPlacementTargetV1Schema, type RuntimeComponentPlacementReceiptV1, type RuntimeComponentInventoryV1, type RuntimeComponentPlacementTargetV1 } from "./runtime-components.js";
 export type ContentContractDigestInput = string | number | boolean | null | undefined | ContentContractDigestInput[] | {
     [key: string]: ContentContractDigestInput;
 };
 export type ContentContractArtifactPayload = {
     [key: string]: ContentContractDigestInput;
-    inputDigest?: ContentProgramSha256;
+    inputDigest?: ContentModelSha256;
 };
-export declare function contentContractSha256(value: ContentContractDigestInput): Promise<ContentProgramSha256>;
-export declare function contentContractTextSha256(value: string): Promise<ContentProgramSha256>;
-export declare function verifyContentProgramReleaseV1(value: z.input<typeof contentProgramReleaseV1Schema>): Promise<ContentProgramReleaseV1>;
-export declare const compiledContentProgramBundleV1Schema: z.ZodObject<{
-    capsule: z.ZodType<import("./content-program.js").ContentProgramJsonValue, unknown, z.core.$ZodTypeInternals<import("./content-program.js").ContentProgramJsonValue, unknown>>;
+export declare function contentContractSha256(value: ContentContractDigestInput): Promise<ContentModelSha256>;
+export declare function contentContractTextSha256(value: string): Promise<ContentModelSha256>;
+export declare function verifyContentModelReleaseV1(value: z.input<typeof contentModelReleaseV1Schema>): Promise<ContentModelReleaseV1>;
+export declare const compiledContentModelBundleV1Schema: z.ZodObject<{
+    capsule: z.ZodType<import("./content-model.js").ContentModelJsonValue, unknown, z.core.$ZodTypeInternals<import("./content-model.js").ContentModelJsonValue, unknown>>;
     artifacts: z.ZodObject<{
-        program: z.ZodObject<{
+        model: z.ZodObject<{
             format: z.ZodLiteral<"spacefast.zero-wordpress">;
             version: z.ZodLiteral<1>;
-            revision: z.core.$ZodBranded<z.ZodString, "ContentProgramSha256", "out">;
+            revision: z.core.$ZodBranded<z.ZodString, "ContentModelSha256", "out">;
             schemas: z.ZodArray<z.ZodObject<{
                 id: z.core.$ZodBranded<z.ZodString, "ContentSchemaId", "out">;
-                sha256: z.core.$ZodBranded<z.ZodString, "ContentProgramSha256", "out">;
-                schema: z.ZodType<import("./content-program.js").ContentProgramJsonValue, unknown, z.core.$ZodTypeInternals<import("./content-program.js").ContentProgramJsonValue, unknown>>;
+                sha256: z.core.$ZodBranded<z.ZodString, "ContentModelSha256", "out">;
+                schema: z.ZodType<import("./content-model.js").ContentModelJsonValue, unknown, z.core.$ZodTypeInternals<import("./content-model.js").ContentModelJsonValue, unknown>>;
             }, z.core.$strict>>;
             wordpress: z.ZodObject<{
-                format: z.ZodLiteral<"spacefast.wordpress-program">;
+                format: z.ZodLiteral<"spacefast.wordpress-content-model">;
                 version: z.ZodLiteral<1>;
                 resources: z.ZodArray<z.ZodObject<{
                     id: z.core.$ZodBranded<z.ZodString, "ContentResourceId", "out">;
@@ -37,9 +37,9 @@ export declare const compiledContentProgramBundleV1Schema: z.ZodObject<{
                     label: z.ZodString;
                     kind: z.ZodEnum<{
                         media: "media";
+                        collection: "collection";
                         posts: "posts";
                         pages: "pages";
-                        collection: "collection";
                     }>;
                     fields: z.ZodArray<z.ZodObject<{
                         id: z.core.$ZodBranded<z.ZodString, "ContentFieldId", "out">;
@@ -107,11 +107,11 @@ export declare const compiledContentProgramBundleV1Schema: z.ZodObject<{
                 id: z.core.$ZodBranded<z.ZodString, "ContentAbilityId", "out">;
                 input: z.ZodObject<{
                     id: z.core.$ZodBranded<z.ZodString, "ContentSchemaId", "out">;
-                    sha256: z.core.$ZodBranded<z.ZodString, "ContentProgramSha256", "out">;
+                    sha256: z.core.$ZodBranded<z.ZodString, "ContentModelSha256", "out">;
                 }, z.core.$strict>;
                 output: z.ZodObject<{
                     id: z.core.$ZodBranded<z.ZodString, "ContentSchemaId", "out">;
-                    sha256: z.core.$ZodBranded<z.ZodString, "ContentProgramSha256", "out">;
+                    sha256: z.core.$ZodBranded<z.ZodString, "ContentModelSha256", "out">;
                 }, z.core.$strict>;
                 permits: z.ZodArray<z.ZodEnum<{
                     "page.view": "page.view";
@@ -162,11 +162,11 @@ export declare const compiledContentProgramBundleV1Schema: z.ZodObject<{
                 id: z.core.$ZodBranded<z.ZodString, "ContentAbilityId", "out">;
                 input: z.ZodObject<{
                     id: z.core.$ZodBranded<z.ZodString, "ContentSchemaId", "out">;
-                    sha256: z.core.$ZodBranded<z.ZodString, "ContentProgramSha256", "out">;
+                    sha256: z.core.$ZodBranded<z.ZodString, "ContentModelSha256", "out">;
                 }, z.core.$strict>;
                 output: z.ZodObject<{
                     id: z.core.$ZodBranded<z.ZodString, "ContentSchemaId", "out">;
-                    sha256: z.core.$ZodBranded<z.ZodString, "ContentProgramSha256", "out">;
+                    sha256: z.core.$ZodBranded<z.ZodString, "ContentModelSha256", "out">;
                 }, z.core.$strict>;
                 permits: z.ZodArray<z.ZodEnum<{
                     "page.view": "page.view";
@@ -220,11 +220,11 @@ export declare const compiledContentProgramBundleV1Schema: z.ZodObject<{
                 id: z.core.$ZodBranded<z.ZodString, "ContentAbilityId", "out">;
                 input: z.ZodObject<{
                     id: z.core.$ZodBranded<z.ZodString, "ContentSchemaId", "out">;
-                    sha256: z.core.$ZodBranded<z.ZodString, "ContentProgramSha256", "out">;
+                    sha256: z.core.$ZodBranded<z.ZodString, "ContentModelSha256", "out">;
                 }, z.core.$strict>;
                 output: z.ZodObject<{
                     id: z.core.$ZodBranded<z.ZodString, "ContentSchemaId", "out">;
-                    sha256: z.core.$ZodBranded<z.ZodString, "ContentProgramSha256", "out">;
+                    sha256: z.core.$ZodBranded<z.ZodString, "ContentModelSha256", "out">;
                 }, z.core.$strict>;
                 permits: z.ZodArray<z.ZodEnum<{
                     "page.view": "page.view";
@@ -279,7 +279,7 @@ export declare const compiledContentProgramBundleV1Schema: z.ZodObject<{
                 componentId: z.core.$ZodBranded<z.ZodString, "ContentComponentId", "out">;
                 props: z.ZodObject<{
                     id: z.core.$ZodBranded<z.ZodString, "ContentSchemaId", "out">;
-                    sha256: z.core.$ZodBranded<z.ZodString, "ContentProgramSha256", "out">;
+                    sha256: z.core.$ZodBranded<z.ZodString, "ContentModelSha256", "out">;
                 }, z.core.$strict>;
             }, z.core.$strict>>;
             hooks: z.ZodArray<z.ZodObject<{
@@ -288,46 +288,100 @@ export declare const compiledContentProgramBundleV1Schema: z.ZodObject<{
                     php: "php";
                     quickjs: "quickjs";
                 }>;
-                artifact: z.core.$ZodBranded<z.ZodString, "ContentProgramSha256", "out">;
+                artifact: z.core.$ZodBranded<z.ZodString, "ContentModelSha256", "out">;
                 export: z.ZodString;
             }, z.core.$strict>>;
-            syncBindings: z.ZodArray<z.ZodObject<{
+            syncBindings: z.ZodArray<z.ZodPipe<z.ZodObject<{
                 id: z.core.$ZodBranded<z.ZodString, "ContentSyncBindingId", "out">;
                 resourceId: z.core.$ZodBranded<z.ZodString, "ContentResourceId", "out">;
                 fieldId: z.core.$ZodBranded<z.ZodString, "ContentFieldId", "out">;
                 source: z.ZodString;
+                publicPath: z.ZodOptional<z.ZodString>;
+                format: z.ZodOptional<z.ZodEnum<{
+                    md: "md";
+                    html: "html";
+                    tsx: "tsx";
+                }>>;
+                compiled: z.ZodOptional<z.ZodObject<{
+                    sha256: z.core.$ZodBranded<z.ZodString, "ContentModelSha256", "out">;
+                }, z.core.$strict>>;
+                documentSeed: z.ZodOptional<z.ZodObject<{
+                    text: z.ZodString;
+                    sha256: z.core.$ZodBranded<z.ZodString, "ContentModelSha256", "out">;
+                }, z.core.$strict>>;
                 slug: z.ZodString;
-            }, z.core.$strict>>;
+            }, z.core.$strict>, z.ZodTransform<{
+                format: "md" | "html" | "tsx";
+                id: string & z.core.$brand<"ContentSyncBindingId">;
+                resourceId: string & z.core.$brand<"ContentResourceId">;
+                fieldId: string & z.core.$brand<"ContentFieldId">;
+                source: string;
+                slug: string;
+                publicPath?: string | undefined;
+                compiled?: {
+                    sha256: string & z.core.$brand<"ContentModelSha256">;
+                } | undefined;
+                documentSeed?: {
+                    text: string;
+                    sha256: string & z.core.$brand<"ContentModelSha256">;
+                } | undefined;
+            }, {
+                id: string & z.core.$brand<"ContentSyncBindingId">;
+                resourceId: string & z.core.$brand<"ContentResourceId">;
+                fieldId: string & z.core.$brand<"ContentFieldId">;
+                source: string;
+                slug: string;
+                publicPath?: string | undefined;
+                format?: "md" | "html" | "tsx" | undefined;
+                compiled?: {
+                    sha256: string & z.core.$brand<"ContentModelSha256">;
+                } | undefined;
+                documentSeed?: {
+                    text: string;
+                    sha256: string & z.core.$brand<"ContentModelSha256">;
+                } | undefined;
+            }>>>;
+            materializations: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                resourceId: z.core.$ZodBranded<z.ZodString, "ContentResourceId", "out">;
+                fieldId: z.core.$ZodBranded<z.ZodString, "ContentFieldId", "out">;
+                directory: z.ZodString;
+                suffix: z.ZodString;
+                format: z.ZodEnum<{
+                    md: "md";
+                    html: "html";
+                    tsx: "tsx";
+                }>;
+            }, z.core.$strict>>>;
         }, z.core.$strict>;
         executables: z.ZodObject<{
             format: z.ZodLiteral<"spacefast.zero-executables">;
             version: z.ZodLiteral<1>;
-            inputDigest: z.core.$ZodBranded<z.ZodString, "ContentProgramSha256", "out">;
+            inputDigest: z.core.$ZodBranded<z.ZodString, "ContentModelSha256", "out">;
             executables: z.ZodArray<z.ZodObject<{
                 id: z.ZodString;
                 runtime: z.ZodEnum<{
                     php: "php";
                     quickjs: "quickjs";
                 }>;
-                artifact: z.core.$ZodBranded<z.ZodString, "ContentProgramSha256", "out">;
+                artifact: z.core.$ZodBranded<z.ZodString, "ContentModelSha256", "out">;
                 export: z.ZodString;
             }, z.core.$strict>>;
         }, z.core.$strict>;
         sdk: z.ZodObject<{
             format: z.ZodLiteral<"spacefast.sdk-descriptors">;
             version: z.ZodLiteral<1>;
-            inputDigest: z.core.$ZodBranded<z.ZodString, "ContentProgramSha256", "out">;
+            inputDigest: z.core.$ZodBranded<z.ZodString, "ContentModelSha256", "out">;
             operations: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
                 id: z.core.$ZodBranded<z.ZodString, "ContentAbilityId", "out">;
                 kind: z.ZodLiteral<"query">;
                 mode: z.ZodLiteral<"read">;
                 input: z.ZodObject<{
                     id: z.core.$ZodBranded<z.ZodString, "ContentSchemaId", "out">;
-                    sha256: z.core.$ZodBranded<z.ZodString, "ContentProgramSha256", "out">;
+                    sha256: z.core.$ZodBranded<z.ZodString, "ContentModelSha256", "out">;
                 }, z.core.$strict>;
                 output: z.ZodObject<{
                     id: z.core.$ZodBranded<z.ZodString, "ContentSchemaId", "out">;
-                    sha256: z.core.$ZodBranded<z.ZodString, "ContentProgramSha256", "out">;
+                    sha256: z.core.$ZodBranded<z.ZodString, "ContentModelSha256", "out">;
                 }, z.core.$strict>;
                 cache: z.ZodDiscriminatedUnion<[z.ZodObject<{
                     kind: z.ZodLiteral<"none">;
@@ -346,11 +400,11 @@ export declare const compiledContentProgramBundleV1Schema: z.ZodObject<{
                 mode: z.ZodLiteral<"write">;
                 input: z.ZodObject<{
                     id: z.core.$ZodBranded<z.ZodString, "ContentSchemaId", "out">;
-                    sha256: z.core.$ZodBranded<z.ZodString, "ContentProgramSha256", "out">;
+                    sha256: z.core.$ZodBranded<z.ZodString, "ContentModelSha256", "out">;
                 }, z.core.$strict>;
                 output: z.ZodObject<{
                     id: z.core.$ZodBranded<z.ZodString, "ContentSchemaId", "out">;
-                    sha256: z.core.$ZodBranded<z.ZodString, "ContentProgramSha256", "out">;
+                    sha256: z.core.$ZodBranded<z.ZodString, "ContentModelSha256", "out">;
                 }, z.core.$strict>;
                 cache: z.ZodObject<{
                     kind: z.ZodLiteral<"none">;
@@ -365,11 +419,11 @@ export declare const compiledContentProgramBundleV1Schema: z.ZodObject<{
                 }>;
                 input: z.ZodObject<{
                     id: z.core.$ZodBranded<z.ZodString, "ContentSchemaId", "out">;
-                    sha256: z.core.$ZodBranded<z.ZodString, "ContentProgramSha256", "out">;
+                    sha256: z.core.$ZodBranded<z.ZodString, "ContentModelSha256", "out">;
                 }, z.core.$strict>;
                 output: z.ZodObject<{
                     id: z.core.$ZodBranded<z.ZodString, "ContentSchemaId", "out">;
-                    sha256: z.core.$ZodBranded<z.ZodString, "ContentProgramSha256", "out">;
+                    sha256: z.core.$ZodBranded<z.ZodString, "ContentModelSha256", "out">;
                 }, z.core.$strict>;
                 cache: z.ZodDiscriminatedUnion<[z.ZodObject<{
                     kind: z.ZodLiteral<"none">;
@@ -392,7 +446,7 @@ export declare const compiledContentProgramBundleV1Schema: z.ZodObject<{
         routes: z.ZodObject<{
             format: z.ZodLiteral<"spacefast.route-contributions">;
             version: z.ZodLiteral<1>;
-            inputDigest: z.core.$ZodBranded<z.ZodString, "ContentProgramSha256", "out">;
+            inputDigest: z.core.$ZodBranded<z.ZodString, "ContentModelSha256", "out">;
             routes: z.ZodArray<z.ZodObject<{
                 abilityId: z.core.$ZodBranded<z.ZodString, "ContentAbilityId", "out">;
                 route: z.ZodObject<{
@@ -415,66 +469,66 @@ export declare const compiledContentProgramBundleV1Schema: z.ZodObject<{
             }, z.core.$strict>>;
         }, z.core.$strict>;
         requirements: z.ZodObject<{
-            format: z.ZodLiteral<"spacefast.program-requirements">;
+            format: z.ZodLiteral<"spacefast.content-model-requirements">;
             version: z.ZodLiteral<1>;
-            inputDigest: z.core.$ZodBranded<z.ZodString, "ContentProgramSha256", "out">;
+            inputDigest: z.core.$ZodBranded<z.ZodString, "ContentModelSha256", "out">;
             wordpressAbi: z.ZodLiteral<1>;
             capabilities: z.ZodArray<z.core.$ZodBranded<z.ZodString, "RuntimeCapabilityId", "out">>;
         }, z.core.$strict>;
     }, z.core.$strict>;
     compiled: z.ZodObject<{
-        format: z.ZodLiteral<"spacefast.compiled-program">;
+        format: z.ZodLiteral<"spacefast.compiled-content-model">;
         version: z.ZodLiteral<1>;
-        program: z.ZodObject<{
+        model: z.ZodObject<{
             format: z.ZodLiteral<"spacefast.zero-wordpress">;
             version: z.ZodLiteral<1>;
-            inputDigest: z.core.$ZodBranded<z.ZodString, "ContentProgramSha256", "out">;
-            sha256: z.core.$ZodBranded<z.ZodString, "ContentProgramSha256", "out">;
+            inputDigest: z.core.$ZodBranded<z.ZodString, "ContentModelSha256", "out">;
+            sha256: z.core.$ZodBranded<z.ZodString, "ContentModelSha256", "out">;
             bytes: z.ZodNumber;
             mediaType: z.ZodLiteral<"application/json">;
         }, z.core.$strict>;
         executables: z.ZodObject<{
             format: z.ZodLiteral<"spacefast.zero-executables">;
             version: z.ZodLiteral<1>;
-            inputDigest: z.core.$ZodBranded<z.ZodString, "ContentProgramSha256", "out">;
-            sha256: z.core.$ZodBranded<z.ZodString, "ContentProgramSha256", "out">;
+            inputDigest: z.core.$ZodBranded<z.ZodString, "ContentModelSha256", "out">;
+            sha256: z.core.$ZodBranded<z.ZodString, "ContentModelSha256", "out">;
             bytes: z.ZodNumber;
             mediaType: z.ZodLiteral<"application/json">;
         }, z.core.$strict>;
         sdk: z.ZodObject<{
             format: z.ZodLiteral<"spacefast.sdk-descriptors">;
             version: z.ZodLiteral<1>;
-            inputDigest: z.core.$ZodBranded<z.ZodString, "ContentProgramSha256", "out">;
-            sha256: z.core.$ZodBranded<z.ZodString, "ContentProgramSha256", "out">;
+            inputDigest: z.core.$ZodBranded<z.ZodString, "ContentModelSha256", "out">;
+            sha256: z.core.$ZodBranded<z.ZodString, "ContentModelSha256", "out">;
             bytes: z.ZodNumber;
             mediaType: z.ZodLiteral<"application/json">;
         }, z.core.$strict>;
         routes: z.ZodObject<{
             format: z.ZodLiteral<"spacefast.route-contributions">;
             version: z.ZodLiteral<1>;
-            inputDigest: z.core.$ZodBranded<z.ZodString, "ContentProgramSha256", "out">;
-            sha256: z.core.$ZodBranded<z.ZodString, "ContentProgramSha256", "out">;
+            inputDigest: z.core.$ZodBranded<z.ZodString, "ContentModelSha256", "out">;
+            sha256: z.core.$ZodBranded<z.ZodString, "ContentModelSha256", "out">;
             bytes: z.ZodNumber;
             mediaType: z.ZodLiteral<"application/json">;
         }, z.core.$strict>;
         requirements: z.ZodObject<{
-            format: z.ZodLiteral<"spacefast.program-requirements">;
+            format: z.ZodLiteral<"spacefast.content-model-requirements">;
             version: z.ZodLiteral<1>;
-            inputDigest: z.core.$ZodBranded<z.ZodString, "ContentProgramSha256", "out">;
-            sha256: z.core.$ZodBranded<z.ZodString, "ContentProgramSha256", "out">;
+            inputDigest: z.core.$ZodBranded<z.ZodString, "ContentModelSha256", "out">;
+            sha256: z.core.$ZodBranded<z.ZodString, "ContentModelSha256", "out">;
             bytes: z.ZodNumber;
             mediaType: z.ZodLiteral<"application/json">;
         }, z.core.$strict>;
     }, z.core.$strict>;
 }, z.core.$strict>;
-export type CompiledContentProgramBundleV1 = z.infer<typeof compiledContentProgramBundleV1Schema>;
-export declare function verifyCompiledContentProgramBundleV1(value: z.input<typeof compiledContentProgramBundleV1Schema>): Promise<CompiledContentProgramBundleV1>;
+export type CompiledContentModelBundleV1 = z.infer<typeof compiledContentModelBundleV1Schema>;
+export declare function verifyCompiledContentModelBundleV1(value: z.input<typeof compiledContentModelBundleV1Schema>): Promise<CompiledContentModelBundleV1>;
 export declare function verifySyncLedgerV1(value: z.input<typeof syncLedgerV1Schema>): Promise<SyncLedgerV1>;
 export declare function verifySyncReconciliationExchangeV1(value: z.input<typeof syncReconciliationExchangeV1Schema>, acknowledgement?: z.input<typeof syncSourceAcknowledgementV1Schema>): Promise<{
     exchange: SyncReconciliationExchangeV1;
     acknowledgement?: SyncSourceAcknowledgementV1;
 }>;
-export declare function verifyContentMarkdownConflictProblem(value: z.input<typeof contentMarkdownConflictProblemSchema>): Promise<ContentMarkdownConflictProblem>;
+export declare function verifyContentSyncConflictProblem(value: z.input<typeof contentSyncConflictProblemSchema>): Promise<ContentSyncConflictProblem>;
 export declare function verifyFrameLaunchTicketClaimsV1(value: z.input<typeof frameLaunchTicketClaimsV1Schema>): Promise<FrameLaunchTicketClaimsV1>;
 export declare function verifyFrameSessionClaimsV1(value: z.input<typeof frameSessionClaimsV1Schema>): Promise<FrameSessionClaimsV1>;
 export declare function verifyFrameProtocolV1(input: {
@@ -493,8 +547,8 @@ export declare function verifyApplicationJournalDeliveryV1(entryValue: z.input<t
     receipt: ApplicationJournalDeliveryReceiptV1;
 }>;
 export declare function verifyRuntimeComponentInventoryV1(value: z.input<typeof runtimeComponentInventoryV1Schema>): Promise<RuntimeComponentInventoryV1>;
-export declare function verifyProgramRuntimeCompatibilityV1(requirementsValue: z.input<typeof programRequirementsV1Schema>, inventoryValue: z.input<typeof runtimeComponentInventoryV1Schema>): Promise<{
-    requirements: z.infer<typeof programRequirementsV1Schema>;
+export declare function verifyContentModelRuntimeCompatibilityV1(requirementsValue: z.input<typeof contentModelRequirementsV1Schema>, inventoryValue: z.input<typeof runtimeComponentInventoryV1Schema>): Promise<{
+    requirements: z.infer<typeof contentModelRequirementsV1Schema>;
     inventory: RuntimeComponentInventoryV1;
 }>;
 export declare function verifyRuntimePlacementReadinessV1(input: {
@@ -515,7 +569,7 @@ export declare function verifyRuntimePlacementReadinessV1(input: {
 export declare function verifySpaceRouteSnapshotV1(value: z.input<typeof spaceRouteSnapshotV1Schema>): Promise<SpaceRouteSnapshotV1>;
 export declare function verifyRouteInventoryV1(value: z.input<typeof routeInventoryV1Schema>): Promise<RouteInventoryV1>;
 export declare function verifyContentArtifactV1(ref: Readonly<{
-    inputDigest: ContentProgramSha256;
-    sha256: ContentProgramSha256;
+    inputDigest: ContentModelSha256;
+    sha256: ContentModelSha256;
     bytes: number;
-}>, artifact: ContentContractArtifactPayload, expectedInputDigest: ContentProgramSha256, payloadCarriesInputDigest?: boolean): Promise<void>;
+}>, artifact: ContentContractArtifactPayload, expectedInputDigest: ContentModelSha256, payloadCarriesInputDigest?: boolean): Promise<void>;

package/dist/contracts/content-contract-verification.js

@@ -1,12 +1,13 @@
 import { z } from "zod";
 import { canonicalJson } from "../utils/canonical-json.js";
 import { applicationJournalDeliveryClaimV1Schema, applicationJournalDeliveryReceiptV1Schema, applicationJournalEntryV1Schema, } from "./application-journal.js";
-import { compiledContentProgramV1Schema, contentExecutableSetV1Schema, contentProgramJsonValueSchema, contentProgramReleaseV1Schema, contentProgramSha256Schema, contentRouteContributionSetV1Schema, contentSdkDescriptorSetV1Schema, } from "./content-program.js";
-import { contentMarkdownConflictProblemSchema, syncReconciliationExchangeV1Schema, syncSourceAcknowledgementV1Schema, syncLedgerV1Schema, } from "./content-sync.js";
+import { contentModelSdkDescriptors } from "./content-model-sdk.js";
+import { compiledContentModelV1Schema, contentExecutableSetV1Schema, contentModelJsonValueSchema, contentModelReleaseV1Schema, contentModelSha256Schema, contentRouteContributionSetV1Schema, contentSdkDescriptorSetV1Schema, } from "./content-model.js";
+import { contentSyncConflictProblemSchema, syncReconciliationExchangeV1Schema, syncSourceAcknowledgementV1Schema, syncLedgerV1Schema, } from "./content-sync.js";
 import { frameGrantDecisionV1Schema, frameLaunchTicketClaimsV1Schema, frameSessionClaimsV1Schema, } from "./frame-session.js";
 import { principalAssertionV1Schema } from "./principal-assertion.js";
 import { routeInventoryV1Schema, spaceRouteSnapshotV1Schema, } from "./route-inventory.js";
-import { programRequirementsV1Schema, runtimeComponentInventoryV1Schema, runtimeComponentPlacementReceiptV1Schema, runtimeComponentPlacementTargetV1Schema, } from "./runtime-components.js";
+import { contentModelRequirementsV1Schema, runtimeComponentInventoryV1Schema, runtimeComponentPlacementReceiptV1Schema, runtimeComponentPlacementTargetV1Schema, } from "./runtime-components.js";
 const encoder = new TextEncoder();
 async function sha256Text(value) {
     const encoded = encoder.encode(value);
@@ -14,7 +15,7 @@ async function sha256Text(value) {
     new Uint8Array(bytes).set(encoded);
     const digest = await globalThis.crypto.subtle.digest("SHA-256", bytes);
     const hex = Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0")).join("");
-    return contentProgramSha256Schema.parse(`sha256:${hex}`);
+    return contentModelSha256Schema.parse(`sha256:${hex}`);
 }
 export function contentContractSha256(value) {
     return sha256Text(canonicalJson(value));
@@ -54,62 +55,49 @@ function frameGrantDecisionMeaning(claims) {
         sessionVersion: claims.sessionVersion,
     });
 }
-export async function verifyContentProgramReleaseV1(value) {
-    const program = contentProgramReleaseV1Schema.parse(value);
-    await Promise.all(program.schemas.map((definition) => requireDigest(definition.sha256, definition.schema, `schema ${definition.id}`)));
-    const { revision, ...meaning } = program;
-    await requireDigest(revision, meaning, "content program revision");
-    return program;
+export async function verifyContentModelReleaseV1(value) {
+    const contentModel = contentModelReleaseV1Schema.parse(value);
+    await Promise.all(contentModel.schemas.map((definition) => requireDigest(definition.sha256, definition.schema, `schema ${definition.id}`)));
+    const { revision, ...meaning } = contentModel;
+    await requireDigest(revision, meaning, "content model revision");
+    return contentModel;
 }
-export const compiledContentProgramBundleV1Schema = z
+export const compiledContentModelBundleV1Schema = z
     .object({
-    capsule: contentProgramJsonValueSchema,
+    capsule: contentModelJsonValueSchema,
     artifacts: z
         .object({
-        program: contentProgramReleaseV1Schema,
+        model: contentModelReleaseV1Schema,
         executables: contentExecutableSetV1Schema,
         sdk: contentSdkDescriptorSetV1Schema,
         routes: contentRouteContributionSetV1Schema,
-        requirements: programRequirementsV1Schema,
+        requirements: contentModelRequirementsV1Schema,
     })
         .strict(),
-    compiled: compiledContentProgramV1Schema,
+    compiled: compiledContentModelV1Schema,
 })
     .strict();
-export async function verifyCompiledContentProgramBundleV1(value) {
-    const bundle = compiledContentProgramBundleV1Schema.parse(value);
+export async function verifyCompiledContentModelBundleV1(value) {
+    const bundle = compiledContentModelBundleV1Schema.parse(value);
     const capsuleDigest = await contentContractSha256(bundle.capsule);
-    const program = await verifyContentProgramReleaseV1(bundle.artifacts.program);
+    const contentModel = await verifyContentModelReleaseV1(bundle.artifacts.model);
     await Promise.all([
-        verifyContentArtifactV1(bundle.compiled.program, bundle.artifacts.program, capsuleDigest, false),
-        verifyContentArtifactV1(bundle.compiled.executables, bundle.artifacts.executables, program.revision),
-        verifyContentArtifactV1(bundle.compiled.sdk, bundle.artifacts.sdk, program.revision),
-        verifyContentArtifactV1(bundle.compiled.routes, bundle.artifacts.routes, program.revision),
-        verifyContentArtifactV1(bundle.compiled.requirements, bundle.artifacts.requirements, program.revision),
+        verifyContentArtifactV1(bundle.compiled.model, bundle.artifacts.model, capsuleDigest, false),
+        verifyContentArtifactV1(bundle.compiled.executables, bundle.artifacts.executables, contentModel.revision),
+        verifyContentArtifactV1(bundle.compiled.sdk, bundle.artifacts.sdk, contentModel.revision),
+        verifyContentArtifactV1(bundle.compiled.routes, bundle.artifacts.routes, contentModel.revision),
+        verifyContentArtifactV1(bundle.compiled.requirements, bundle.artifacts.requirements, contentModel.revision),
     ]);
-    requireSameValue(bundle.artifacts.executables.executables.map((executable) => executable.id), [...program.abilities.map((ability) => ability.id), ...program.hooks.map((hook) => hook.id)], "content executable identities");
-    requireSameValue(bundle.artifacts.sdk.operations.map(({ invalidates: _invalidates, ...operation }) => operation), program.abilities.map((ability) => ({
-        id: ability.id,
-        kind: ability.kind,
-        mode: ability.mode,
-        input: ability.input,
-        output: ability.output,
-        cache: ability.cache,
-    })), "content SDK operation descriptors");
-    const abilityIds = new Set(program.abilities.map((ability) => ability.id));
-    for (const operation of bundle.artifacts.sdk.operations) {
-        for (const invalidatedAbility of operation.invalidates) {
-            if (!abilityIds.has(invalidatedAbility)) {
-                throw new TypeError(`content SDK operation ${operation.id} invalidates unknown ability ${invalidatedAbility}`);
-            }
-        }
-    }
-    requireSameValue(bundle.artifacts.sdk.sync, program.syncBindings.map((binding) => ({
-        id: binding.id,
-        resourceId: binding.resourceId,
-        source: binding.source,
-    })), "content SDK sync descriptors");
-    requireSameValue(bundle.artifacts.routes.routes, program.abilities.flatMap((ability) => ability.exposure.kind === "routed"
+    requireSameValue(bundle.artifacts.executables.executables.map((executable) => executable.id), [
+        ...contentModel.abilities.map((ability) => ability.id),
+        ...contentModel.hooks.map((hook) => hook.id),
+    ], "content executable identities");
+    // The whole descriptor set, `invalidates` included. A compiled bundle carries
+    // its SDK descriptors, but it does not get to choose them: they are a pure
+    // function of the release, and a bundle whose descriptors disagree with that
+    // derivation is refused rather than trusted.
+    requireSameValue(bundle.artifacts.sdk, contentModelSdkDescriptors(contentModel), "content SDK descriptors");
+    requireSameValue(bundle.artifacts.routes.routes, contentModel.abilities.flatMap((ability) => ability.exposure.kind === "routed"
         ? [{ abilityId: ability.id, route: ability.exposure.route }]
         : []), "content route contributions");
     return bundle;
@@ -118,15 +106,15 @@ export async function verifySyncLedgerV1(value) {
     const ledger = syncLedgerV1Schema.parse(value);
     const { revision, ...meaning } = ledger;
     await requireDigest(revision, meaning, "sync ledger revision");
-    await requireTextDigest(ledger.markdownDigest, ledger.baseMarkdown, "sync ledger Markdown");
+    await requireTextDigest(ledger.textDigest, ledger.baseText, "sync ledger text");
     return ledger;
 }
 export async function verifySyncReconciliationExchangeV1(value, acknowledgement) {
     const exchange = syncReconciliationExchangeV1Schema.parse(value);
     await verifySyncLedgerV1(exchange.receipt.ledger);
     if (exchange.receipt.status !== "pulled" &&
-        exchange.receipt.ledger.baseMarkdown !== exchange.request.markdown) {
-        throw new TypeError(`sync ${exchange.receipt.status} receipt must commit the requested Markdown`);
+        exchange.receipt.ledger.baseText !== exchange.request.text) {
+        throw new TypeError(`sync ${exchange.receipt.status} receipt must commit the requested text`);
     }
     if (acknowledgement === undefined)
         return { exchange };
@@ -145,9 +133,9 @@ export async function verifySyncReconciliationExchangeV1(value, acknowledgement)
     }
     return { exchange, acknowledgement: parsedAcknowledgement };
 }
-export async function verifyContentMarkdownConflictProblem(value) {
-    const problem = contentMarkdownConflictProblemSchema.parse(value);
-    await Promise.all(["base", "source", "wordpress"].map((side) => requireTextDigest(problem.details[side].digest, problem.details[side].markdown, `sync conflict ${side}`)));
+export async function verifyContentSyncConflictProblem(value) {
+    const problem = contentSyncConflictProblemSchema.parse(value);
+    await Promise.all(["base", "source", "wordpress"].map((side) => requireTextDigest(problem.details[side].digest, problem.details[side].text, `sync conflict ${side}`)));
     return problem;
 }
 export async function verifyFrameLaunchTicketClaimsV1(value) {
@@ -225,8 +213,8 @@ export async function verifyRuntimeComponentInventoryV1(value) {
     await requireDigest(digest, meaning, "runtime component inventory");
     return inventory;
 }
-export async function verifyProgramRuntimeCompatibilityV1(requirementsValue, inventoryValue) {
-    const requirements = programRequirementsV1Schema.parse(requirementsValue);
+export async function verifyContentModelRuntimeCompatibilityV1(requirementsValue, inventoryValue) {
+    const requirements = contentModelRequirementsV1Schema.parse(requirementsValue);
     const inventory = await verifyRuntimeComponentInventoryV1(inventoryValue);
     const provided = new Set(inventory.components.flatMap((component) => component.provides));
     const missing = requirements.capabilities.filter((capability) => !provided.has(capability));

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

@@ -0,0 +1,97 @@
+import type { z } from "zod";
+import { contentModelFieldSchema, type ContentModelSha256, type ContentSyncFormat } from "./content-model.js";
+import { type CompiledContentModelArtifactsV1 } from "./runtime-components.js";
+/**
+ * The last mile of every "author → ContentModel" compiler: given resources,
+ * sync bindings, and pages that already speak the IR's vocabulary, produce the
+ * release and the five artifacts a published version declares.
+ *
+ * What lives here is the part that is the same no matter where the model came
+ * from — native adoption, the JSON Schema each resource publishes, the required
+ * runtime capabilities, revision and artifact digests, and the SDK derivation.
+ * What does not live here is translation: mapping someone else's config onto
+ * these resources is that adapter's whole job, and every adapter does it
+ * differently.
+ */
+/** The IR's own field shape, before branding — what a compiler builds. */
+export type ContentModelEmitField = z.input<typeof contentModelFieldSchema>;
+export type ContentModelEmitResource = {
+    readonly id: string;
+    readonly name: string;
+    readonly label: string;
+    readonly kind: "posts" | "pages" | "media" | "collection";
+    readonly publicRead: boolean;
+    readonly fields: readonly ContentModelEmitField[];
+};
+export type ContentModelEmitSyncBinding = {
+    readonly id: string;
+    readonly resourceId: string;
+    readonly fieldId: string;
+    readonly source: string;
+    readonly publicPath?: string;
+    readonly format: ContentSyncFormat;
+    /**
+     * The digest of the markup a one-way source compiled to. Required for a
+     * compile-class format and refused for the two-way ones — the release schema
+     * enforces both, so a caller that omits it here fails at emit, not later.
+     */
+    readonly compiled?: {
+        readonly sha256: ContentModelSha256;
+    };
+    /** Exact source bytes for MD/HTML, rendered markup for TSX; sealed by the model revision. */
+    readonly documentSeed?: {
+        readonly text: string;
+        readonly sha256: ContentModelSha256;
+    };
+    readonly slug: string;
+};
+/**
+ * Where one collection field puts a document WordPress created before any file
+ * backed it. Restates what the capsule declared, so it travels with the release
+ * rather than being recomputed at request time.
+ */
+export type ContentModelEmitMaterialization = {
+    readonly resourceId: string;
+    readonly fieldId: string;
+    readonly directory: string;
+    readonly suffix: string;
+    readonly format: ContentSyncFormat;
+};
+export type ContentModelEmitPage = {
+    readonly id: string;
+    readonly sourceKey: string;
+    readonly path: string;
+    readonly title: string;
+    readonly componentId: string;
+};
+export type ContentModelEmitInput = {
+    /**
+     * Every resource the model declares. Natives the author never mentioned are
+     * filled in here, so a caller passes only what it actually translated.
+     */
+    readonly resources: readonly ContentModelEmitResource[];
+    readonly syncBindings?: readonly ContentModelEmitSyncBinding[];
+    readonly materializations?: readonly ContentModelEmitMaterialization[];
+    readonly pages?: readonly ContentModelEmitPage[];
+    /**
+     * The bytes the model was compiled from. It becomes `compiled.model.inputDigest`
+     * and is what lets a reviewer tell one compile apart from a rerun of the same
+     * one.
+     */
+    readonly sourceDigest: ContentModelSha256;
+};
+/**
+ * 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 declare function emitContentModelArtifacts(input: ContentModelEmitInput): Promise<CompiledContentModelArtifactsV1>;