@treeseed/sdk 0.13.0-rc.67 → 0.13.0-rc.69

package/dist/operator-contracts/catalog/provider-environment-operations.d.ts

@@ -0,0 +1,41 @@
+export declare const PROVIDER_ENVIRONMENT_OPERATIONS: {
+    readonly registrationCode: {
+        readonly status: import("../control-plane-operation.js").ControlPlaneOperationBinding<{
+            teamId: string;
+        }, {}, Record<string, unknown> | undefined, Record<string, unknown>>;
+        readonly reveal: import("../control-plane-operation.js").ControlPlaneOperationBinding<{
+            teamId: string;
+        }, {}, Record<string, unknown> | undefined, Record<string, unknown>>;
+        readonly rotate: import("../control-plane-operation.js").ControlPlaneOperationBinding<{
+            teamId: string;
+        }, {}, Record<string, unknown> | undefined, Record<string, unknown>>;
+    };
+    readonly environmentProfiles: {
+        readonly list: import("../control-plane-operation.js").ControlPlaneOperationBinding<{
+            teamId: string;
+            providerId: string;
+        }, {}, Record<string, unknown> | undefined, Record<string, unknown>>;
+        readonly show: import("../control-plane-operation.js").ControlPlaneOperationBinding<{
+            teamId: string;
+            providerId: string;
+            profileId: string;
+        }, {}, Record<string, unknown> | undefined, Record<string, unknown>>;
+        readonly publish: import("../control-plane-operation.js").ControlPlaneOperationBinding<{
+            profileId: string;
+        }, {}, Record<string, unknown>, Record<string, unknown>>;
+    };
+    readonly environmentGrants: {
+        readonly show: import("../control-plane-operation.js").ControlPlaneOperationBinding<{
+            teamId: string;
+            assignmentId: string;
+        }, {}, Record<string, unknown> | undefined, Record<string, unknown>>;
+        readonly put: import("../control-plane-operation.js").ControlPlaneOperationBinding<{
+            teamId: string;
+            assignmentId: string;
+        }, {}, Record<string, unknown> | undefined, Record<string, unknown>>;
+        readonly revoke: import("../control-plane-operation.js").ControlPlaneOperationBinding<{
+            teamId: string;
+            assignmentId: string;
+        }, {}, Record<string, unknown> | undefined, Record<string, unknown>>;
+    };
+};

package/dist/operator-contracts/catalog/provider-environment-operations.js

@@ -0,0 +1,61 @@
+import { z } from "zod";
+import { defineOperation } from "../operation-builder.js";
+const empty = z.object({}).strict();
+const none = z.undefined();
+const record = z.record(z.unknown());
+function teamOperation(operationId, method, path, pathShape, options = {}) {
+  const kind = method === "GET" ? "read" : "mutation";
+  const riskClass = options.risk ?? "ordinary";
+  return defineOperation({
+    operationId,
+    description: `${kind === "read" ? "Read" : "Apply"} ${operationId}.`,
+    rest: { method, path },
+    parameters: `treeseed.${operationId}.parameters/v1`,
+    capability: options.capability ?? (kind === "read" ? "providers.read" : "providers.write"),
+    authentication: "oauth",
+    oauthScopes: kind === "read" ? ["treeseed:read"] : ["treeseed:admin"],
+    kind,
+    riskClass,
+    confirmation: riskClass === "ordinary" ? "never" : "input_required",
+    surfaces: ["rest", "cli"],
+    cacheScope: kind === "read" ? "principal" : "none",
+    pagination: options.pagination ?? "none",
+    concurrencyRequired: options.concurrency ?? ["DELETE", "PUT"].includes(method),
+    redactedPaths: options.redactedPaths
+  }, { path: z.object(pathShape).strict(), query: kind === "read" ? record : empty, body: kind === "read" ? none : record, output: record });
+}
+const providerPublish = defineOperation({
+  operationId: "providers.environment.profiles.publish",
+  description: "Publish a value-free provider environment profile descriptor.",
+  rest: { method: "PUT", path: "/v1/provider/environment-profiles/{profileId}" },
+  parameters: "treeseed.providers.environment.profiles.publish.parameters/v1",
+  capability: "providers.execute",
+  authentication: "provider",
+  oauthScopes: [],
+  kind: "mutation",
+  riskClass: "ordinary",
+  confirmation: "never",
+  surfaces: ["rest"],
+  cacheScope: "none",
+  pagination: "none"
+}, { path: z.object({ profileId: z.string().min(1) }).strict(), query: empty, body: record, output: record });
+const PROVIDER_ENVIRONMENT_OPERATIONS = {
+  registrationCode: {
+    status: teamOperation("providers.registration.code.status", "GET", "/v1/teams/{teamId}/capacity-provider-registration-code", { teamId: z.string().min(1) }),
+    reveal: teamOperation("providers.registration.code.reveal", "POST", "/v1/teams/{teamId}/capacity-provider-registration-code/reveal", { teamId: z.string().min(1) }, { risk: "credential", redactedPaths: ["output.registrationCode"] }),
+    rotate: teamOperation("providers.registration.code.rotate", "POST", "/v1/teams/{teamId}/capacity-provider-registration-code/rotate", { teamId: z.string().min(1) }, { risk: "credential", redactedPaths: ["output.registrationCode"], concurrency: true })
+  },
+  environmentProfiles: {
+    list: teamOperation("providers.environment.profiles.list", "GET", "/v1/teams/{teamId}/capacity-providers/{providerId}/environment-profiles", { teamId: z.string().min(1), providerId: z.string().min(1) }, { pagination: "cursor" }),
+    show: teamOperation("providers.environment.profiles.show", "GET", "/v1/teams/{teamId}/capacity-providers/{providerId}/environment-profiles/{profileId}", { teamId: z.string().min(1), providerId: z.string().min(1), profileId: z.string().min(1) }),
+    publish: providerPublish
+  },
+  environmentGrants: {
+    show: teamOperation("providers.environment.grants.show", "GET", "/v1/teams/{teamId}/assignments/{assignmentId}/environment-grant", { teamId: z.string().min(1), assignmentId: z.string().min(1) }),
+    put: teamOperation("providers.environment.grants.put", "PUT", "/v1/teams/{teamId}/assignments/{assignmentId}/environment-grant", { teamId: z.string().min(1), assignmentId: z.string().min(1) }, { risk: "authority" }),
+    revoke: teamOperation("providers.environment.grants.revoke", "DELETE", "/v1/teams/{teamId}/assignments/{assignmentId}/environment-grant", { teamId: z.string().min(1), assignmentId: z.string().min(1) }, { risk: "destructive" })
+  }
+};
+export {
+  PROVIDER_ENVIRONMENT_OPERATIONS
+};

package/dist/operator-contracts/control-plane-operations.d.ts

@@ -1955,6 +1955,17 @@ export declare const CONTROL_PLANE_OPERATIONS: {
         readonly connect: import("./control-plane-operation.js").ControlPlaneOperationBinding<{
             teamId: string;
         }, {}, Record<string, unknown> | undefined, Record<string, unknown>>;
+        readonly registrationCode: {
+            readonly status: import("./control-plane-operation.js").ControlPlaneOperationBinding<{
+                teamId: string;
+            }, {}, Record<string, unknown> | undefined, Record<string, unknown>>;
+            readonly reveal: import("./control-plane-operation.js").ControlPlaneOperationBinding<{
+                teamId: string;
+            }, {}, Record<string, unknown> | undefined, Record<string, unknown>>;
+            readonly rotate: import("./control-plane-operation.js").ControlPlaneOperationBinding<{
+                teamId: string;
+            }, {}, Record<string, unknown> | undefined, Record<string, unknown>>;
+        };
         readonly disconnect: import("./control-plane-operation.js").ControlPlaneOperationBinding<{
             teamId: string;
             connectionId: string;
@@ -1990,6 +2001,34 @@ export declare const CONTROL_PLANE_OPERATIONS: {
                 connectionId: string;
             }, {}, Record<string, unknown> | undefined, Record<string, unknown>>;
         };
+        readonly environmentProfiles: {
+            readonly list: import("./control-plane-operation.js").ControlPlaneOperationBinding<{
+                teamId: string;
+                providerId: string;
+            }, {}, Record<string, unknown> | undefined, Record<string, unknown>>;
+            readonly show: import("./control-plane-operation.js").ControlPlaneOperationBinding<{
+                teamId: string;
+                providerId: string;
+                profileId: string;
+            }, {}, Record<string, unknown> | undefined, Record<string, unknown>>;
+            readonly publish: import("./control-plane-operation.js").ControlPlaneOperationBinding<{
+                profileId: string;
+            }, {}, Record<string, unknown>, Record<string, unknown>>;
+        };
+        readonly environmentGrants: {
+            readonly show: import("./control-plane-operation.js").ControlPlaneOperationBinding<{
+                teamId: string;
+                assignmentId: string;
+            }, {}, Record<string, unknown> | undefined, Record<string, unknown>>;
+            readonly put: import("./control-plane-operation.js").ControlPlaneOperationBinding<{
+                teamId: string;
+                assignmentId: string;
+            }, {}, Record<string, unknown> | undefined, Record<string, unknown>>;
+            readonly revoke: import("./control-plane-operation.js").ControlPlaneOperationBinding<{
+                teamId: string;
+                assignmentId: string;
+            }, {}, Record<string, unknown> | undefined, Record<string, unknown>>;
+        };
         readonly register: import("./control-plane-operation.js").ControlPlaneOperationBinding<{}, {}, Record<string, unknown> | undefined, Record<string, unknown>>;
         readonly registration: import("./control-plane-operation.js").ControlPlaneOperationBinding<{
             requestId: string;

package/dist/operator-contracts/control-plane-operations.js

@@ -6,6 +6,7 @@ import { adminAccountOperations, adminTeamOperations } from "./catalog/admin-acc
 import { TREEAI_CONTROL_PLANE_OPERATIONS } from "./catalog/treeai-operations.js";
 import { capabilityOntologyOperations } from "./catalog/capability-ontology-operations.js";
 import { knowledgeShareOperations } from "./catalog/knowledge-share-operations.js";
+import { PROVIDER_ENVIRONMENT_OPERATIONS } from "./catalog/provider-environment-operations.js";
 import { buildControlPlaneCatalog, flattenControlPlaneOperations } from "./catalog/control-plane-catalog.js";
 const empty = z.object({}).strict();
 const none = z.undefined();
@@ -465,6 +466,7 @@ const CONTROL_PLANE_OPERATIONS = {
     status: resource("providers.status", "GET", "/v1/teams/{teamId}/capacity-providers/{providerId}/status", { teamId: z.string().min(1), providerId: z.string().min(1) }, { capability: "providers.read", surfaces: ["rest", "cli", "mcp_tool"] }),
     diagnose: resource("providers.diagnose", "GET", "/v1/teams/{teamId}/capacity-providers/{providerId}/diagnosis", { teamId: z.string().min(1), providerId: z.string().min(1) }, { capability: "providers.read", surfaces: ["rest", "cli", "mcp_tool"] }),
     connect: resource("providers.connect", "POST", "/v1/teams/{teamId}/capacity-provider-connections", { teamId: z.string().min(1) }, { capability: "providers.write", scopes: ["treeseed:admin"], surfaces: ["rest", "cli"], risk: "credential", redactedPaths: ["body.enrollmentToken"] }),
+    registrationCode: PROVIDER_ENVIRONMENT_OPERATIONS.registrationCode,
     disconnect: resource("providers.disconnect", "POST", "/v1/teams/{teamId}/capacity-provider-connections/{connectionId}/disconnect", { teamId: z.string().min(1), connectionId: z.string().min(1) }, { capability: "providers.write", scopes: ["treeseed:admin"], surfaces: ["rest", "cli"], risk: "destructive" }),
     requests: {
       list: resource("providers.requests.list", "GET", "/v1/teams/{teamId}/capacity-provider-requests", { teamId: z.string().min(1) }, { capability: "providers.read", surfaces: ["rest", "cli"], pagination: "cursor" }),
@@ -477,6 +479,8 @@ const CONTROL_PLANE_OPERATIONS = {
       rotate: resource("providers.credentials.rotate", "POST", "/v1/teams/{teamId}/capacity-provider-connections/{connectionId}/credentials/rotate", { teamId: z.string().min(1), connectionId: z.string().min(1) }, { capability: "providers.write", scopes: ["treeseed:admin"], surfaces: ["rest", "cli"], risk: "credential" }),
       revoke: resource("providers.credentials.revoke", "POST", "/v1/teams/{teamId}/capacity-provider-connections/{connectionId}/credentials/revoke", { teamId: z.string().min(1), connectionId: z.string().min(1) }, { capability: "providers.write", scopes: ["treeseed:admin"], surfaces: ["rest", "cli"], risk: "irreversible" })
     },
+    environmentProfiles: PROVIDER_ENVIRONMENT_OPERATIONS.environmentProfiles,
+    environmentGrants: PROVIDER_ENVIRONMENT_OPERATIONS.environmentGrants,
     register: noPathProvider("providers.register", "POST", "/v1/provider-registrations", { authentication: "signed_request", redactedPaths: ["body.registrationKey"] }),
     registration: providerPath("providers.registration.show", "GET", "/v1/provider-registrations/{requestId}", { requestId: z.string().min(1) }, { authentication: "signed_request", read: true }),
     exchangeCredential: providerPath("providers.registration.credential", "POST", "/v1/provider-registrations/{requestId}/credential", { requestId: z.string().min(1) }, { authentication: "signed_request", redactedPaths: ["body.proof"] }),

package/dist/platform/contracts.d.ts

@@ -149,6 +149,20 @@ export declare const projectCreatePlanSchema: z.ZodObject<{
         visibility: "public" | "private";
     }>;
     steps: z.ZodArray<z.ZodEnum<["project", "repository", "template", "library", "inventory"]>, "many">;
+    actions: z.ZodArray<z.ZodObject<{
+        step: z.ZodEnum<["project", "repository", "template", "library", "inventory"]>;
+        action: z.ZodEnum<["create", "adopt", "apply", "bind", "publish", "noop", "blocked"]>;
+    }, "strip", z.ZodTypeAny, {
+        action: "noop" | "blocked" | "create" | "adopt" | "apply" | "bind" | "publish";
+        step: "project" | "library" | "repository" | "template" | "inventory";
+    }, {
+        action: "noop" | "blocked" | "create" | "adopt" | "apply" | "bind" | "publish";
+        step: "project" | "library" | "repository" | "template" | "inventory";
+    }>, "many">;
+    observationDigest: z.ZodString;
+    planDigest: z.ZodString;
+    ok: z.ZodBoolean;
+    blockers: z.ZodArray<z.ZodString, "many">;
 }, "strict", z.ZodTypeAny, {
     slug: string;
     schemaVersion: "treeseed.platform-project-create-plan/v1";
@@ -157,6 +171,9 @@ export declare const projectCreatePlanSchema: z.ZodObject<{
         owner: string;
         visibility: "public" | "private";
     };
+    blockers: string[];
+    ok: boolean;
+    planDigest: string;
     template: {
         id: string;
         version: string;
@@ -164,6 +181,11 @@ export declare const projectCreatePlanSchema: z.ZodObject<{
     };
     team: string;
     steps: ("project" | "library" | "repository" | "template" | "inventory")[];
+    actions: {
+        action: "noop" | "blocked" | "create" | "adopt" | "apply" | "bind" | "publish";
+        step: "project" | "library" | "repository" | "template" | "inventory";
+    }[];
+    observationDigest: string;
 }, {
     slug: string;
     schemaVersion: "treeseed.platform-project-create-plan/v1";
@@ -172,6 +194,9 @@ export declare const projectCreatePlanSchema: z.ZodObject<{
         owner: string;
         visibility: "public" | "private";
     };
+    blockers: string[];
+    ok: boolean;
+    planDigest: string;
     template: {
         id: string;
         version: string;
@@ -179,9 +204,15 @@ export declare const projectCreatePlanSchema: z.ZodObject<{
     };
     team: string;
     steps: ("project" | "library" | "repository" | "template" | "inventory")[];
+    actions: {
+        action: "noop" | "blocked" | "create" | "adopt" | "apply" | "bind" | "publish";
+        step: "project" | "library" | "repository" | "template" | "inventory";
+    }[];
+    observationDigest: string;
 }>;
-export declare const projectCreateReceiptSchema: z.ZodObject<Omit<{
-    schemaVersion: z.ZodLiteral<"treeseed.platform-project-create-plan/v1">;
+export declare const projectCreateReceiptSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"treeseed.platform-project-create-receipt/v1">;
+    planDigest: z.ZodString;
     slug: z.ZodString;
     template: z.ZodObject<{
         id: z.ZodString;
@@ -210,13 +241,20 @@ export declare const projectCreateReceiptSchema: z.ZodObject<Omit<{
         owner: string;
         visibility: "public" | "private";
     }>;
-    steps: z.ZodArray<z.ZodEnum<["project", "repository", "template", "library", "inventory"]>, "many">;
-}, "schemaVersion"> & {
-    schemaVersion: z.ZodLiteral<"treeseed.platform-project-create-receipt/v1">;
     projectId: z.ZodString;
     repositoryUrl: z.ZodString;
     libraryBindingId: z.ZodString;
     inventoryVersion: z.ZodNumber;
+    actions: z.ZodArray<z.ZodObject<{
+        step: z.ZodEnum<["project", "repository", "template", "library", "inventory"]>;
+        action: z.ZodEnum<["create", "adopt", "apply", "bind", "publish", "noop", "blocked"]>;
+    }, "strip", z.ZodTypeAny, {
+        action: "noop" | "blocked" | "create" | "adopt" | "apply" | "bind" | "publish";
+        step: "project" | "library" | "repository" | "template" | "inventory";
+    }, {
+        action: "noop" | "blocked" | "create" | "adopt" | "apply" | "bind" | "publish";
+        step: "project" | "library" | "repository" | "template" | "inventory";
+    }>, "many">;
 }, "strict", z.ZodTypeAny, {
     slug: string;
     schemaVersion: "treeseed.platform-project-create-receipt/v1";
@@ -225,13 +263,17 @@ export declare const projectCreateReceiptSchema: z.ZodObject<Omit<{
         owner: string;
         visibility: "public" | "private";
     };
+    planDigest: string;
     template: {
         id: string;
         version: string;
         digest: string;
     };
     team: string;
-    steps: ("project" | "library" | "repository" | "template" | "inventory")[];
+    actions: {
+        action: "noop" | "blocked" | "create" | "adopt" | "apply" | "bind" | "publish";
+        step: "project" | "library" | "repository" | "template" | "inventory";
+    }[];
     projectId: string;
     repositoryUrl: string;
     libraryBindingId: string;
@@ -244,13 +286,17 @@ export declare const projectCreateReceiptSchema: z.ZodObject<Omit<{
         owner: string;
         visibility: "public" | "private";
     };
+    planDigest: string;
     template: {
         id: string;
         version: string;
         digest: string;
     };
     team: string;
-    steps: ("project" | "library" | "repository" | "template" | "inventory")[];
+    actions: {
+        action: "noop" | "blocked" | "create" | "adopt" | "apply" | "bind" | "publish";
+        step: "project" | "library" | "repository" | "template" | "inventory";
+    }[];
     projectId: string;
     repositoryUrl: string;
     libraryBindingId: string;

package/dist/platform/contracts.js

@@ -27,14 +27,28 @@ const projectCreatePlanSchema = z.object({
   template: z.object({ id: z.string().min(1), version: z.string().min(1), digest }),
   team: z.string().min(1),
   repository: z.object({ owner: z.string().min(1), name: z.string().min(1), visibility: z.enum(["public", "private"]) }),
-  steps: z.array(z.enum(["project", "repository", "template", "library", "inventory"]))
+  steps: z.array(z.enum(["project", "repository", "template", "library", "inventory"])),
+  actions: z.array(z.object({
+    step: z.enum(["project", "repository", "template", "library", "inventory"]),
+    action: z.enum(["create", "adopt", "apply", "bind", "publish", "noop", "blocked"])
+  })),
+  observationDigest: digest,
+  planDigest: digest,
+  ok: z.boolean(),
+  blockers: z.array(z.string())
 }).strict();
-const projectCreateReceiptSchema = projectCreatePlanSchema.omit({ schemaVersion: true }).extend({
+const projectCreateReceiptSchema = z.object({
   schemaVersion: z.literal("treeseed.platform-project-create-receipt/v1"),
+  planDigest: digest,
+  slug: projectCreatePlanSchema.shape.slug,
+  template: projectCreatePlanSchema.shape.template,
+  team: z.string().min(1),
+  repository: projectCreatePlanSchema.shape.repository,
   projectId: z.string().min(1),
   repositoryUrl: z.string().url(),
   libraryBindingId: z.string().min(1),
-  inventoryVersion: z.number().int().positive()
+  inventoryVersion: z.number().int().positive(),
+  actions: projectCreatePlanSchema.shape.actions
 }).strict();
 const providerRegistrationRequestSchema = z.object({
   schemaVersion: z.literal("treeseed.provider-registration-request/v1"),

package/dist/platform/index.d.ts

@@ -1,5 +1,6 @@
 export * from './schemas.js';
 export * from './contracts.js';
 export * from './inventory.js';
+export * from './project-create.js';
 export * from './workset.js';
 export * from './verification.js';

package/dist/platform/index.js

@@ -1,5 +1,6 @@
 export * from "./schemas.js";
 export * from "./contracts.js";
 export * from "./inventory.js";
+export * from "./project-create.js";
 export * from "./workset.js";
 export * from "./verification.js";

package/dist/platform/project-create.d.ts

@@ -0,0 +1,49 @@
+import { type ProjectCreatePlan, type ProjectCreateReceipt } from './contracts.js';
+export type ProjectCreateStep = 'project' | 'repository' | 'template' | 'library' | 'inventory';
+export type ProjectCreateState = 'missing' | 'ready' | 'conflict';
+export interface ProjectCreateTarget {
+    slug: string;
+    template: {
+        id: string;
+        version: string;
+        digest: string;
+    };
+    team: string;
+    repository: {
+        owner: string;
+        name: string;
+        visibility: 'public' | 'private';
+    };
+}
+export interface ProjectCreateObservation {
+    project: {
+        state: ProjectCreateState;
+        id?: string;
+    };
+    repository: {
+        state: ProjectCreateState;
+        url?: string;
+    };
+    template: {
+        state: ProjectCreateState;
+        digest?: string;
+    };
+    library: {
+        state: ProjectCreateState;
+        bindingId?: string;
+    };
+    inventory: {
+        state: ProjectCreateState;
+        version?: number;
+    };
+}
+export interface ProjectCreateAuthority {
+    observe(target: ProjectCreateTarget): Promise<ProjectCreateObservation>;
+    reconcileProject(target: ProjectCreateTarget): Promise<void>;
+    reconcileRepository(target: ProjectCreateTarget): Promise<void>;
+    applyTemplate(target: ProjectCreateTarget): Promise<void>;
+    reconcileLibrary(target: ProjectCreateTarget): Promise<void>;
+    publishInventory(target: ProjectCreateTarget): Promise<void>;
+}
+export declare function planPlatformProjectCreate(target: ProjectCreateTarget, authority: Pick<ProjectCreateAuthority, 'observe'>): Promise<ProjectCreatePlan>;
+export declare function applyPlatformProjectCreate(plan: ProjectCreatePlan, authority: ProjectCreateAuthority): Promise<ProjectCreateReceipt>;

package/dist/platform/project-create.js

@@ -0,0 +1,75 @@
+import { createHash } from "node:crypto";
+import { projectCreatePlanSchema, projectCreateReceiptSchema } from "./contracts.js";
+const steps = ["project", "repository", "template", "library", "inventory"];
+const actionFor = {
+  project: "create",
+  repository: "adopt",
+  template: "apply",
+  library: "bind",
+  inventory: "publish"
+};
+function canonical(value) {
+  if (Array.isArray(value)) return `[${value.map(canonical).join(",")}]`;
+  if (value && typeof value === "object") return `{${Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, item]) => `${JSON.stringify(key)}:${canonical(item)}`).join(",")}}`;
+  return JSON.stringify(value);
+}
+function digest(value) {
+  return `sha256:${createHash("sha256").update(canonical(value)).digest("hex")}`;
+}
+function blockers(observation) {
+  return steps.filter((step) => observation[step].state === "conflict").map((step) => `${step}_conflicts_with_requested_target`);
+}
+async function planPlatformProjectCreate(target, authority) {
+  const observation = await authority.observe(target);
+  const conflicts = blockers(observation);
+  const base = {
+    schemaVersion: "treeseed.platform-project-create-plan/v1",
+    ...target,
+    steps: [...steps],
+    actions: steps.map((step) => ({ step, action: observation[step].state === "ready" ? "noop" : observation[step].state === "conflict" ? "blocked" : actionFor[step] })),
+    observationDigest: digest(observation),
+    ok: conflicts.length === 0,
+    blockers: conflicts
+  };
+  return projectCreatePlanSchema.parse({ ...base, planDigest: digest(base) });
+}
+function requireReady(observation) {
+  const incomplete = steps.filter((step) => observation[step].state !== "ready");
+  if (incomplete.length) throw new Error(`Project creation postconditions are incomplete: ${incomplete.join(", ")}.`);
+  if (!observation.project.id || !observation.repository.url || !observation.library.bindingId || !observation.inventory.version) {
+    throw new Error("Project creation authority returned incomplete receipt identities.");
+  }
+}
+async function applyPlatformProjectCreate(plan, authority) {
+  const accepted = projectCreatePlanSchema.parse(plan);
+  const { planDigest: _planDigest, ...unsigned } = accepted;
+  if (digest(unsigned) !== accepted.planDigest) throw new Error("Project creation plan digest does not match its frozen inputs.");
+  if (!accepted.ok || accepted.blockers.length) throw new Error("Blocked project creation plans cannot be applied.");
+  const target = { slug: accepted.slug, template: accepted.template, team: accepted.team, repository: accepted.repository };
+  const current = await authority.observe(target);
+  if (digest(current) !== accepted.observationDigest) throw new Error("Project creation authority changed after planning; create a new plan.");
+  const operations = {
+    project: authority.reconcileProject,
+    repository: authority.reconcileRepository,
+    template: authority.applyTemplate,
+    library: authority.reconcileLibrary,
+    inventory: authority.publishInventory
+  };
+  for (const item of accepted.actions) if (item.action !== "noop") await operations[item.step].call(authority, target);
+  const final = await authority.observe(target);
+  requireReady(final);
+  return projectCreateReceiptSchema.parse({
+    schemaVersion: "treeseed.platform-project-create-receipt/v1",
+    planDigest: accepted.planDigest,
+    ...target,
+    projectId: final.project.id,
+    repositoryUrl: final.repository.url,
+    libraryBindingId: final.library.bindingId,
+    inventoryVersion: final.inventory.version,
+    actions: accepted.actions
+  });
+}
+export {
+  applyPlatformProjectCreate,
+  planPlatformProjectCreate
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@treeseed/sdk",
-  "version": "0.13.0-rc.67",
+  "version": "0.13.0-rc.69",
   "description": "Portable TreeSeed contracts, standards, and typed remote control-plane clients.",
   "license": "Apache-2.0",
   "repository": {