@treeseed/sdk 0.13.0-rc.54 → 0.13.0-rc.56

package/dist/capacity-provider/environment-catalog.js

@@ -0,0 +1,116 @@
+import { createHash, createPublicKey, verify } from "node:crypto";
+import { z } from "zod";
+const identifier = z.string().regex(/^[a-z][a-z0-9._-]{0,127}$/u);
+const digest = z.string().regex(/^sha256:[a-f0-9]{64}$/u);
+const version = z.string().regex(/^\d+\.\d+\.\d+$/u);
+const sandboxEnvironmentContractSchema = z.object({
+  id: identifier,
+  version,
+  digest,
+  capabilities: z.array(identifier)
+}).strict();
+const provenance = z.object({
+  sourceRepository: z.string().url(),
+  sourceRevision: z.union([z.string().regex(/^[a-f0-9]{40}$/u), digest]),
+  buildRecipeDigest: digest,
+  sbomDigest: digest,
+  signature: z.object({ keyId: identifier, algorithm: z.enum(["Ed25519", "cosign"]), value: z.string().min(1) }).strict()
+}).strict();
+const sandboxEnvironmentCatalogEntrySchema = z.object({
+  id: identifier,
+  version,
+  kind: z.enum(["base", "extension"]),
+  contract: sandboxEnvironmentContractSchema,
+  image: z.object({ reference: z.string().min(1), digest, architectures: z.array(z.enum(["amd64", "arm64"])).min(1), operatingSystem: z.literal("linux") }).strict(),
+  derivedFrom: z.array(z.object({ entryId: identifier, version, imageDigest: digest }).strict()).min(1).nullable(),
+  provenance,
+  qualification: z.object({ suiteId: identifier, suiteVersion: version, evidenceDigest: digest, status: z.literal("passed"), completedAt: z.string().datetime() }).strict(),
+  status: z.enum(["active", "deprecated", "revoked"]),
+  createdAt: z.string().datetime()
+}).strict().superRefine((entry, context) => {
+  if (new Set(entry.image.architectures).size !== entry.image.architectures.length) context.addIssue({ code: z.ZodIssueCode.custom, path: ["image", "architectures"], message: "Image architectures must be unique." });
+  if (entry.kind === "base" && entry.derivedFrom !== null) context.addIssue({ code: z.ZodIssueCode.custom, path: ["derivedFrom"], message: "Base environments cannot derive from another catalog entry." });
+  if (entry.kind === "extension" && entry.derivedFrom === null) context.addIssue({ code: z.ZodIssueCode.custom, path: ["derivedFrom"], message: "Extended environments require exact catalog bases." });
+});
+const sandboxEnvironmentCatalogSchema = z.object({
+  schemaVersion: z.literal("treeseed.sandbox-environment-catalog/v1"),
+  generation: z.number().int().positive(),
+  catalogDigest: digest,
+  rootPolicy: z.object({ allowedBaseImageDigests: z.array(digest).min(1) }).strict(),
+  entries: z.array(sandboxEnvironmentCatalogEntrySchema),
+  createdAt: z.string().datetime(),
+  signature: z.object({ keyId: identifier, algorithm: z.literal("Ed25519"), value: z.string().min(1) }).strict()
+}).strict().superRefine((catalog, context) => {
+  const entries = new Map(catalog.entries.map((entry) => [`${entry.id}@${entry.version}`, entry]));
+  for (const [index, entry] of catalog.entries.entries()) {
+    if (entry.kind === "base" && !catalog.rootPolicy.allowedBaseImageDigests.includes(entry.image.digest)) context.addIssue({ code: z.ZodIssueCode.custom, path: ["entries", index, "image", "digest"], message: "Base image is not an allowed catalog root." });
+    if (entry.kind !== "extension" || !entry.derivedFrom) continue;
+    const parentArchitectures = /* @__PURE__ */ new Set();
+    for (const [parentIndex, reference] of entry.derivedFrom.entries()) {
+      const parent = entries.get(`${reference.entryId}@${reference.version}`);
+      if (!parent || parent.image.digest !== reference.imageDigest) {
+        context.addIssue({ code: z.ZodIssueCode.custom, path: ["entries", index, "derivedFrom", parentIndex], message: "Environment extension does not bind an exact entry in this catalog." });
+        continue;
+      }
+      const pending = [parent], seen = /* @__PURE__ */ new Set(), roots = [];
+      while (pending.length) {
+        const current = pending.pop(), key = `${current.id}@${current.version}`;
+        if (seen.has(key)) {
+          roots.length = 0;
+          break;
+        }
+        seen.add(key);
+        if (current.kind === "base") {
+          roots.push(current);
+          continue;
+        }
+        for (const ancestor of current.derivedFrom ?? []) {
+          const resolved = entries.get(`${ancestor.entryId}@${ancestor.version}`);
+          if (!resolved || resolved.image.digest !== ancestor.imageDigest) {
+            roots.length = 0;
+            pending.length = 0;
+            break;
+          }
+          pending.push(resolved);
+        }
+      }
+      if (!roots.length || roots.some((root) => !catalog.rootPolicy.allowedBaseImageDigests.includes(root.image.digest))) context.addIssue({ code: z.ZodIssueCode.custom, path: ["entries", index, "derivedFrom", parentIndex], message: "Environment extension does not resolve to an allowed catalog root." });
+      else for (const root of roots) for (const architecture of root.image.architectures) parentArchitectures.add(architecture);
+    }
+    for (const architecture of entry.image.architectures) if (!parentArchitectures.has(architecture)) context.addIssue({ code: z.ZodIssueCode.custom, path: ["entries", index, "derivedFrom"], message: `Environment extension has no allowed ${architecture} base.` });
+  }
+});
+const providerSandboxEnvironmentAvailabilitySchema = z.object({
+  schemaVersion: z.literal("treeseed.provider-sandbox-environments/v1"),
+  providerId: z.string().min(1),
+  catalogGeneration: z.number().int().positive(),
+  catalogDigest: digest,
+  entries: z.array(z.object({ entryId: identifier, version, contractDigest: digest, imageDigest: digest, status: z.enum(["pulling", "ready", "failed", "quarantined"]), checkedAt: z.string().datetime(), reason: z.string().min(1).nullable() }).strict())
+}).strict();
+function canonical(value) {
+  if (value === null || typeof value !== "object") return JSON.stringify(value);
+  if (Array.isArray(value)) return `[${value.map(canonical).join(",")}]`;
+  return `{${Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, item]) => `${JSON.stringify(key)}:${canonical(item)}`).join(",")}}`;
+}
+function sandboxEnvironmentCatalogDigest(value) {
+  return `sha256:${createHash("sha256").update(canonical(value)).digest("hex")}`;
+}
+function sandboxEnvironmentCatalogSigningBytes(value) {
+  return Buffer.from(canonical({ ...value, signature: { ...value.signature, value: "" } }));
+}
+function verifySandboxEnvironmentCatalog(value, publicJwk) {
+  const catalog = sandboxEnvironmentCatalogSchema.parse(value);
+  const { catalogDigest, signature: _signature, ...material } = catalog;
+  if (sandboxEnvironmentCatalogDigest(material) !== catalogDigest) throw new Error("Sandbox environment catalog digest does not match its canonical content.");
+  if (!verify(null, sandboxEnvironmentCatalogSigningBytes(catalog), createPublicKey({ key: publicJwk, format: "jwk" }), Buffer.from(catalog.signature.value, "base64url"))) throw new Error("Sandbox environment catalog signature is invalid.");
+  return catalog;
+}
+export {
+  providerSandboxEnvironmentAvailabilitySchema,
+  sandboxEnvironmentCatalogDigest,
+  sandboxEnvironmentCatalogEntrySchema,
+  sandboxEnvironmentCatalogSchema,
+  sandboxEnvironmentCatalogSigningBytes,
+  sandboxEnvironmentContractSchema,
+  verifySandboxEnvironmentCatalog
+};

package/dist/capacity-provider/index.d.ts

@@ -1,3 +1,7 @@
 export * from './client.js';
 export * from './contracts/index.js';
 export * from './validation.js';
+export * from './sandbox-contracts.js';
+export * from './environment-catalog.js';
+export * from './capability-ontology.js';
+export * from './core-capability-catalog.js';

package/dist/capacity-provider/index.js

@@ -1,3 +1,7 @@
 export * from "./client.js";
 export * from "./contracts/index.js";
 export * from "./validation.js";
+export * from "./sandbox-contracts.js";
+export * from "./environment-catalog.js";
+export * from "./capability-ontology.js";
+export * from "./core-capability-catalog.js";

package/dist/capacity-provider/sandbox-contracts.d.ts

@@ -0,0 +1,543 @@
+import { z } from 'zod';
+declare const sandboxProfile: z.ZodString;
+export declare const sandboxAssignmentSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"treeseed.sandbox-assignment/v1">;
+    assignmentId: z.ZodString;
+    attempt: z.ZodNumber;
+    runnerId: z.ZodString;
+    providerId: z.ZodString;
+    teamId: z.ZodString;
+    projectId: z.ZodString;
+    profile: z.ZodString;
+    environmentContract: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        version: z.ZodString;
+        digest: z.ZodString;
+        capabilities: z.ZodArray<z.ZodString, "many">;
+    }, "strict", z.ZodTypeAny, {
+        id: string;
+        digest: string;
+        version: string;
+        capabilities: string[];
+    }, {
+        id: string;
+        digest: string;
+        version: string;
+        capabilities: string[];
+    }>>;
+    guestImage: z.ZodString;
+    guestImageDigest: z.ZodString;
+    identityManifestDigest: z.ZodString;
+    contextManifestDigest: z.ZodString;
+    resources: z.ZodObject<{
+        cpuCores: z.ZodNumber;
+        memoryBytes: z.ZodNumber;
+        diskBytes: z.ZodNumber;
+        durationSeconds: z.ZodNumber;
+        processLimit: z.ZodNumber;
+        outputBytes: z.ZodNumber;
+    }, "strict", z.ZodTypeAny, {
+        cpuCores: number;
+        memoryBytes: number;
+        diskBytes: number;
+        durationSeconds: number;
+        processLimit: number;
+        outputBytes: number;
+    }, {
+        cpuCores: number;
+        memoryBytes: number;
+        diskBytes: number;
+        durationSeconds: number;
+        processLimit: number;
+        outputBytes: number;
+    }>;
+    inputs: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        digest: z.ZodString;
+        bytes: z.ZodNumber;
+        disposition: z.ZodEnum<["read-only", "copy-on-write"]>;
+        mediaType: z.ZodString;
+        targetPath: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        id: string;
+        mediaType: string;
+        digest: string;
+        bytes: number;
+        disposition: "read-only" | "copy-on-write";
+        targetPath: string;
+    }, {
+        id: string;
+        mediaType: string;
+        digest: string;
+        bytes: number;
+        disposition: "read-only" | "copy-on-write";
+        targetPath: string;
+    }>, "many">;
+    outputs: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        path: z.ZodString;
+        mediaType: z.ZodString;
+        maxBytes: z.ZodNumber;
+    }, "strict", z.ZodTypeAny, {
+        path: string;
+        id: string;
+        mediaType: string;
+        maxBytes: number;
+    }, {
+        path: string;
+        id: string;
+        mediaType: string;
+        maxBytes: number;
+    }>, "many">;
+    network: z.ZodObject<{
+        defaultDeny: z.ZodLiteral<true>;
+        relayUrl: z.ZodString;
+        allowedServices: z.ZodArray<z.ZodString, "many">;
+        connectedDevelopmentSessionId: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        defaultDeny: true;
+        relayUrl: string;
+        allowedServices: string[];
+        connectedDevelopmentSessionId?: string | undefined;
+    }, {
+        defaultDeny: true;
+        relayUrl: string;
+        allowedServices: string[];
+        connectedDevelopmentSessionId?: string | undefined;
+    }>;
+    modelPolicy: z.ZodObject<{
+        provider: z.ZodString;
+        model: z.ZodString;
+        capabilities: z.ZodArray<z.ZodString, "many">;
+        maxInputTokens: z.ZodOptional<z.ZodNumber>;
+        maxOutputTokens: z.ZodOptional<z.ZodNumber>;
+        maxCost: z.ZodOptional<z.ZodNumber>;
+    }, "strict", z.ZodTypeAny, {
+        provider: string;
+        capabilities: string[];
+        model: string;
+        maxInputTokens?: number | undefined;
+        maxOutputTokens?: number | undefined;
+        maxCost?: number | undefined;
+    }, {
+        provider: string;
+        capabilities: string[];
+        model: string;
+        maxInputTokens?: number | undefined;
+        maxOutputTokens?: number | undefined;
+        maxCost?: number | undefined;
+    }>;
+    credentialHandles: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        profileId: z.ZodString;
+        revealAllowed: z.ZodLiteral<false>;
+    }, "strict", z.ZodTypeAny, {
+        id: string;
+        profileId: string;
+        revealAllowed: false;
+    }, {
+        id: string;
+        profileId: string;
+        revealAllowed: false;
+    }>, "many">;
+    treeDxHandleIds: z.ZodArray<z.ZodString, "many">;
+    leaseExpiresAt: z.ZodString;
+    signature: z.ZodObject<{
+        keyId: z.ZodString;
+        algorithm: z.ZodLiteral<"Ed25519">;
+        value: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        value: string;
+        algorithm: "Ed25519";
+        keyId: string;
+    }, {
+        value: string;
+        algorithm: "Ed25519";
+        keyId: string;
+    }>;
+}, "strict", z.ZodTypeAny, {
+    teamId: string;
+    assignmentId: string;
+    schemaVersion: "treeseed.sandbox-assignment/v1";
+    outputs: {
+        path: string;
+        id: string;
+        mediaType: string;
+        maxBytes: number;
+    }[];
+    resources: {
+        cpuCores: number;
+        memoryBytes: number;
+        diskBytes: number;
+        durationSeconds: number;
+        processLimit: number;
+        outputBytes: number;
+    };
+    projectId: string;
+    profile: string;
+    network: {
+        defaultDeny: true;
+        relayUrl: string;
+        allowedServices: string[];
+        connectedDevelopmentSessionId?: string | undefined;
+    };
+    guestImage: string;
+    guestImageDigest: string;
+    providerId: string;
+    runnerId: string;
+    inputs: {
+        id: string;
+        mediaType: string;
+        digest: string;
+        bytes: number;
+        disposition: "read-only" | "copy-on-write";
+        targetPath: string;
+    }[];
+    signature: {
+        value: string;
+        algorithm: "Ed25519";
+        keyId: string;
+    };
+    leaseExpiresAt: string;
+    attempt: number;
+    identityManifestDigest: string;
+    contextManifestDigest: string;
+    modelPolicy: {
+        provider: string;
+        capabilities: string[];
+        model: string;
+        maxInputTokens?: number | undefined;
+        maxOutputTokens?: number | undefined;
+        maxCost?: number | undefined;
+    };
+    credentialHandles: {
+        id: string;
+        profileId: string;
+        revealAllowed: false;
+    }[];
+    treeDxHandleIds: string[];
+    environmentContract?: {
+        id: string;
+        digest: string;
+        version: string;
+        capabilities: string[];
+    } | undefined;
+}, {
+    teamId: string;
+    assignmentId: string;
+    schemaVersion: "treeseed.sandbox-assignment/v1";
+    outputs: {
+        path: string;
+        id: string;
+        mediaType: string;
+        maxBytes: number;
+    }[];
+    resources: {
+        cpuCores: number;
+        memoryBytes: number;
+        diskBytes: number;
+        durationSeconds: number;
+        processLimit: number;
+        outputBytes: number;
+    };
+    projectId: string;
+    profile: string;
+    network: {
+        defaultDeny: true;
+        relayUrl: string;
+        allowedServices: string[];
+        connectedDevelopmentSessionId?: string | undefined;
+    };
+    guestImage: string;
+    guestImageDigest: string;
+    providerId: string;
+    runnerId: string;
+    inputs: {
+        id: string;
+        mediaType: string;
+        digest: string;
+        bytes: number;
+        disposition: "read-only" | "copy-on-write";
+        targetPath: string;
+    }[];
+    signature: {
+        value: string;
+        algorithm: "Ed25519";
+        keyId: string;
+    };
+    leaseExpiresAt: string;
+    attempt: number;
+    identityManifestDigest: string;
+    contextManifestDigest: string;
+    modelPolicy: {
+        provider: string;
+        capabilities: string[];
+        model: string;
+        maxInputTokens?: number | undefined;
+        maxOutputTokens?: number | undefined;
+        maxCost?: number | undefined;
+    };
+    credentialHandles: {
+        id: string;
+        profileId: string;
+        revealAllowed: false;
+    }[];
+    treeDxHandleIds: string[];
+    environmentContract?: {
+        id: string;
+        digest: string;
+        version: string;
+        capabilities: string[];
+    } | undefined;
+}>;
+export declare const sandboxEventSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"treeseed.sandbox-event/v1">;
+    sandboxId: z.ZodString;
+    assignmentId: z.ZodString;
+    sequence: z.ZodNumber;
+    occurredAt: z.ZodString;
+    type: z.ZodEnum<["sandbox.created", "sandbox.ready", "execution.started", "execution.progress", "tool.requested", "tool.completed", "execution.completed", "execution.failed", "sandbox.destroyed"]>;
+    payload: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strict", z.ZodTypeAny, {
+    assignmentId: string;
+    sequence: number;
+    schemaVersion: "treeseed.sandbox-event/v1";
+    type: "sandbox.created" | "sandbox.ready" | "execution.started" | "execution.progress" | "tool.requested" | "tool.completed" | "execution.completed" | "execution.failed" | "sandbox.destroyed";
+    payload: Record<string, unknown>;
+    occurredAt: string;
+    sandboxId: string;
+}, {
+    assignmentId: string;
+    sequence: number;
+    schemaVersion: "treeseed.sandbox-event/v1";
+    type: "sandbox.created" | "sandbox.ready" | "execution.started" | "execution.progress" | "tool.requested" | "tool.completed" | "execution.completed" | "execution.failed" | "sandbox.destroyed";
+    occurredAt: string;
+    sandboxId: string;
+    payload?: Record<string, unknown> | undefined;
+}>;
+export declare const sandboxLeaseRenewalSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"treeseed.sandbox-lease-renewal/v1">;
+    sandboxId: z.ZodString;
+    assignmentId: z.ZodString;
+    providerId: z.ZodString;
+    teamId: z.ZodString;
+    leaseExpiresAt: z.ZodString;
+    issuedAt: z.ZodString;
+    signature: z.ZodObject<{
+        keyId: z.ZodString;
+        algorithm: z.ZodLiteral<"Ed25519">;
+        value: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        value: string;
+        algorithm: "Ed25519";
+        keyId: string;
+    }, {
+        value: string;
+        algorithm: "Ed25519";
+        keyId: string;
+    }>;
+}, "strict", z.ZodTypeAny, {
+    teamId: string;
+    assignmentId: string;
+    schemaVersion: "treeseed.sandbox-lease-renewal/v1";
+    providerId: string;
+    signature: {
+        value: string;
+        algorithm: "Ed25519";
+        keyId: string;
+    };
+    issuedAt: string;
+    leaseExpiresAt: string;
+    sandboxId: string;
+}, {
+    teamId: string;
+    assignmentId: string;
+    schemaVersion: "treeseed.sandbox-lease-renewal/v1";
+    providerId: string;
+    signature: {
+        value: string;
+        algorithm: "Ed25519";
+        keyId: string;
+    };
+    issuedAt: string;
+    leaseExpiresAt: string;
+    sandboxId: string;
+}>;
+export declare const sandboxResultSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"treeseed.sandbox-result/v1">;
+    sandboxId: z.ZodString;
+    assignmentId: z.ZodString;
+    status: z.ZodEnum<["completed", "failed", "cancelled", "expired"]>;
+    summary: z.ZodString;
+    responseMarkdown: z.ZodOptional<z.ZodString>;
+    artifacts: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        path: z.ZodString;
+        digest: z.ZodString;
+        mediaType: z.ZodString;
+        bytes: z.ZodNumber;
+    }, "strict", z.ZodTypeAny, {
+        path: string;
+        id: string;
+        mediaType: string;
+        digest: string;
+        bytes: number;
+    }, {
+        path: string;
+        id: string;
+        mediaType: string;
+        digest: string;
+        bytes: number;
+    }>, "many">;
+    usage: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    diagnostics: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    teardown: z.ZodObject<{
+        verified: z.ZodBoolean;
+        completedAt: z.ZodNullable<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        completedAt: string | null;
+        verified: boolean;
+    }, {
+        completedAt: string | null;
+        verified: boolean;
+    }>;
+}, "strict", z.ZodTypeAny, {
+    assignmentId: string;
+    schemaVersion: "treeseed.sandbox-result/v1";
+    status: "expired" | "failed" | "completed" | "cancelled";
+    artifacts: {
+        path: string;
+        id: string;
+        mediaType: string;
+        digest: string;
+        bytes: number;
+    }[];
+    summary: string;
+    usage: Record<string, unknown>;
+    diagnostics: Record<string, unknown>;
+    sandboxId: string;
+    teardown: {
+        completedAt: string | null;
+        verified: boolean;
+    };
+    responseMarkdown?: string | undefined;
+}, {
+    assignmentId: string;
+    schemaVersion: "treeseed.sandbox-result/v1";
+    status: "expired" | "failed" | "completed" | "cancelled";
+    artifacts: {
+        path: string;
+        id: string;
+        mediaType: string;
+        digest: string;
+        bytes: number;
+    }[];
+    summary: string;
+    sandboxId: string;
+    teardown: {
+        completedAt: string | null;
+        verified: boolean;
+    };
+    usage?: Record<string, unknown> | undefined;
+    diagnostics?: Record<string, unknown> | undefined;
+    responseMarkdown?: string | undefined;
+}>;
+export declare const providerEnvironmentReceiptSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"treeseed.provider-environment-receipt/v1">;
+    assignmentId: z.ZodString;
+    offerId: z.ZodString;
+    providerId: z.ZodString;
+    imageDigest: z.ZodString;
+    baseLineage: z.ZodObject<{
+        baseImageDigest: z.ZodString;
+        provenanceDigest: z.ZodString;
+        architectures: z.ZodArray<z.ZodEnum<["amd64", "arm64"]>, "many">;
+    }, "strict", z.ZodTypeAny, {
+        baseImageDigest: string;
+        provenanceDigest: string;
+        architectures: ("amd64" | "arm64")[];
+    }, {
+        baseImageDigest: string;
+        provenanceDigest: string;
+        architectures: ("amd64" | "arm64")[];
+    }>;
+    securityAttestationDigest: z.ZodString;
+    brokerVersion: z.ZodString;
+    teardown: z.ZodObject<{
+        verified: z.ZodBoolean;
+        completedAt: z.ZodNullable<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        completedAt: string | null;
+        verified: boolean;
+    }, {
+        completedAt: string | null;
+        verified: boolean;
+    }>;
+    createdAt: z.ZodString;
+    signature: z.ZodObject<{
+        keyId: z.ZodString;
+        algorithm: z.ZodLiteral<"Ed25519">;
+        value: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        value: string;
+        algorithm: "Ed25519";
+        keyId: string;
+    }, {
+        value: string;
+        algorithm: "Ed25519";
+        keyId: string;
+    }>;
+}, "strict", z.ZodTypeAny, {
+    assignmentId: string;
+    schemaVersion: "treeseed.provider-environment-receipt/v1";
+    createdAt: string;
+    providerId: string;
+    signature: {
+        value: string;
+        algorithm: "Ed25519";
+        keyId: string;
+    };
+    offerId: string;
+    teardown: {
+        completedAt: string | null;
+        verified: boolean;
+    };
+    imageDigest: string;
+    baseLineage: {
+        baseImageDigest: string;
+        provenanceDigest: string;
+        architectures: ("amd64" | "arm64")[];
+    };
+    securityAttestationDigest: string;
+    brokerVersion: string;
+}, {
+    assignmentId: string;
+    schemaVersion: "treeseed.provider-environment-receipt/v1";
+    createdAt: string;
+    providerId: string;
+    signature: {
+        value: string;
+        algorithm: "Ed25519";
+        keyId: string;
+    };
+    offerId: string;
+    teardown: {
+        completedAt: string | null;
+        verified: boolean;
+    };
+    imageDigest: string;
+    baseLineage: {
+        baseImageDigest: string;
+        provenanceDigest: string;
+        architectures: ("amd64" | "arm64")[];
+    };
+    securityAttestationDigest: string;
+    brokerVersion: string;
+}>;
+export type SandboxAssignment = z.infer<typeof sandboxAssignmentSchema>;
+export type SandboxEvent = z.infer<typeof sandboxEventSchema>;
+export type SandboxLeaseRenewal = z.infer<typeof sandboxLeaseRenewalSchema>;
+export type SandboxResult = z.infer<typeof sandboxResultSchema>;
+export type ProviderEnvironmentReceipt = z.infer<typeof providerEnvironmentReceiptSchema>;
+export type SandboxEnvironmentProfile = z.infer<typeof sandboxProfile>;
+export {};