@treeseed/sdk 0.13.0-rc.37 → 0.13.0-rc.39

package/dist/operator-contracts/communication/contracts.js

@@ -5,52 +5,84 @@ const communicationRecipientSchema = z.object({
 }).strict();
 const communicationSendRequestSchema = z.object({
   message: z.string().trim().min(1).max(1e5),
-  topic: z.string().trim().min(1).max(240).optional(),
-  projectId: z.string().min(1).optional(),
+  projectId: z.string().min(1),
   recipients: z.array(z.string().trim().min(1)).max(100).optional(),
-  waitSeconds: z.number().int().min(0).max(3600).optional()
+  timeoutSeconds: z.number().int().min(1).max(3600).optional()
 }).strict();
 const communicationTargetSchema = communicationRecipientSchema.extend({
   projectSlug: z.string().min(1),
   definitionRevision: z.string().min(1),
+  revisions: z.object({
+    project: z.string().min(1),
+    library: z.string().min(1),
+    agentDefinition: z.string().min(1),
+    chatProfile: z.string().min(1)
+  }).strict(),
   invocationId: z.string().min(1).nullable(),
-  status: z.enum(["queued", "running", "responded", "failed", "cancelled"])
+  requirement: z.enum(["required", "optional"]),
+  parentInvocationId: z.string().min(1).nullable(),
+  depth: z.number().int().nonnegative(),
+  status: z.enum(["queued", "running", "responded", "abstained", "failed", "cancelled"]),
+  requestedAt: z.string().datetime(),
+  updatedAt: z.string().datetime(),
+  completedAt: z.string().datetime().nullable(),
+  failure: z.object({ code: z.string().min(1), message: z.string().nullable() }).strict().nullable(),
+  capacity: z.object({
+    assignmentId: z.string().min(1).nullable(),
+    providerId: z.string().min(1).nullable(),
+    executionProviderId: z.string().min(1).nullable(),
+    laneId: z.string().min(1).nullable(),
+    lanePurpose: z.string().min(1).nullable(),
+    status: z.string().min(1).nullable(),
+    assignedAt: z.string().datetime().nullable(),
+    claimedAt: z.string().datetime().nullable(),
+    completedAt: z.string().datetime().nullable(),
+    returnedAt: z.string().datetime().nullable(),
+    failedAt: z.string().datetime().nullable()
+  }).strict()
 });
 const communicationResponseSchema = communicationRecipientSchema.extend({
   invocationId: z.string().min(1),
   assignmentId: z.string().min(1).nullable(),
   messageRef: z.string().min(1),
   markdown: z.string(),
-  status: z.enum(["responded", "failed", "cancelled"]),
+  requirement: z.enum(["required", "optional"]),
+  status: z.enum(["responded", "abstained", "failed", "cancelled"]),
   createdAt: z.string().datetime()
 });
 const communicationSendReceiptSchema = z.object({
-  schemaVersion: z.literal("treeseed.communication-send-receipt/v1"),
+  schemaVersion: z.literal("treeseed.communication-send-receipt/v2"),
   sendId: z.string().min(1),
   teamId: z.string().min(1),
   channel: z.string().min(1),
-  topic: z.string().nullable(),
+  topic: z.object({ id: z.string().min(1), slug: z.string().min(1) }).strict(),
+  projectStream: z.object({ id: z.string().min(1), projectId: z.string().min(1), projectSlug: z.string().min(1) }).strict(),
   discussionId: z.string().min(1),
   messageRef: z.string().min(1),
+  sourceMessage: z.string(),
   status: z.enum(["queued", "running", "complete", "partial", "failed"]),
   targets: z.array(communicationTargetSchema),
   responses: z.array(communicationResponseSchema),
   createdAt: z.string().datetime(),
-  updatedAt: z.string().datetime()
+  updatedAt: z.string().datetime(),
+  replayed: z.boolean()
 }).strict();
 const providerDiscussionResponseRequestSchema = z.object({
   leaseToken: z.string().min(1),
   runnerId: z.string().min(1),
-  markdown: z.string().trim().min(1).max(1e5),
+  outcome: z.enum(["responded", "abstained"]).default("responded"),
+  markdown: z.string().trim().min(1).max(1e5).optional(),
   summary: z.string().trim().min(1).max(4e3).optional(),
   usage: z.record(z.unknown()).optional()
-}).strict();
+}).strict().superRefine((value, context) => {
+  if (value.outcome === "responded" && !value.markdown) context.addIssue({ code: z.ZodIssueCode.custom, path: ["markdown"], message: "A response requires Markdown." });
+});
 const providerDiscussionResponseReceiptSchema = z.object({
   schemaVersion: z.literal("treeseed.provider-discussion-response-receipt/v1"),
   assignmentId: z.string().min(1),
   invocationId: z.string().min(1),
   messageRef: z.string().min(1),
-  status: z.literal("responded"),
+  status: z.enum(["responded", "abstained"]),
   settledAt: z.string().datetime()
 }).strict();
 export {

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

@@ -466,72 +466,151 @@ export declare const CONTROL_PLANE_OPERATIONS: {
             channel: string;
         }, {}, {
             message: string;
-            projectId?: string | undefined;
+            projectId: string;
+            timeoutSeconds?: number | undefined;
             recipients?: string[] | undefined;
-            topic?: string | undefined;
-            waitSeconds?: number | undefined;
         }, {
             status: "partial" | "failed" | "complete" | "running" | "queued";
-            schemaVersion: "treeseed.communication-send-receipt/v1";
+            schemaVersion: "treeseed.communication-send-receipt/v2";
             createdAt: string;
             responses: {
-                status: "failed" | "cancelled" | "responded";
+                status: "failed" | "cancelled" | "responded" | "abstained";
                 createdAt: string;
                 projectId: string;
                 agentSlug: string;
                 assignmentId: string | null;
                 invocationId: string;
+                requirement: "required" | "optional";
                 messageRef: string;
                 markdown: string;
             }[];
             teamId: string;
             channel: string;
-            topic: string | null;
+            updatedAt: string;
             messageRef: string;
             sendId: string;
+            topic: {
+                id: string;
+                slug: string;
+            };
+            projectStream: {
+                id: string;
+                projectId: string;
+                projectSlug: string;
+            };
             discussionId: string;
+            sourceMessage: string;
             targets: {
-                status: "failed" | "running" | "cancelled" | "queued" | "responded";
+                status: "failed" | "running" | "cancelled" | "queued" | "responded" | "abstained";
+                completedAt: string | null;
                 projectId: string;
                 agentSlug: string;
+                capacity: {
+                    status: string | null;
+                    completedAt: string | null;
+                    providerId: string | null;
+                    assignmentId: string | null;
+                    executionProviderId: string | null;
+                    laneId: string | null;
+                    lanePurpose: string | null;
+                    assignedAt: string | null;
+                    claimedAt: string | null;
+                    returnedAt: string | null;
+                    failedAt: string | null;
+                };
                 projectSlug: string;
                 definitionRevision: string;
+                revisions: {
+                    project: string;
+                    library: string;
+                    agentDefinition: string;
+                    chatProfile: string;
+                };
                 invocationId: string | null;
+                requirement: "required" | "optional";
+                parentInvocationId: string | null;
+                depth: number;
+                requestedAt: string;
+                updatedAt: string;
+                failure: {
+                    code: string;
+                    message: string | null;
+                } | null;
             }[];
-            updatedAt: string;
+            replayed: boolean;
         }>;
         readonly sendStatus: ControlPlaneOperationBinding<{
             teamId: string;
             sendId: string;
         }, {}, undefined, {
             status: "partial" | "failed" | "complete" | "running" | "queued";
-            schemaVersion: "treeseed.communication-send-receipt/v1";
+            schemaVersion: "treeseed.communication-send-receipt/v2";
             createdAt: string;
             responses: {
-                status: "failed" | "cancelled" | "responded";
+                status: "failed" | "cancelled" | "responded" | "abstained";
                 createdAt: string;
                 projectId: string;
                 agentSlug: string;
                 assignmentId: string | null;
                 invocationId: string;
+                requirement: "required" | "optional";
                 messageRef: string;
                 markdown: string;
             }[];
             teamId: string;
             channel: string;
-            topic: string | null;
+            updatedAt: string;
             messageRef: string;
             sendId: string;
+            topic: {
+                id: string;
+                slug: string;
+            };
+            projectStream: {
+                id: string;
+                projectId: string;
+                projectSlug: string;
+            };
             discussionId: string;
+            sourceMessage: string;
             targets: {
-                status: "failed" | "running" | "cancelled" | "queued" | "responded";
+                status: "failed" | "running" | "cancelled" | "queued" | "responded" | "abstained";
+                completedAt: string | null;
                 projectId: string;
                 agentSlug: string;
+                capacity: {
+                    status: string | null;
+                    completedAt: string | null;
+                    providerId: string | null;
+                    assignmentId: string | null;
+                    executionProviderId: string | null;
+                    laneId: string | null;
+                    lanePurpose: string | null;
+                    assignedAt: string | null;
+                    claimedAt: string | null;
+                    returnedAt: string | null;
+                    failedAt: string | null;
+                };
                 projectSlug: string;
                 definitionRevision: string;
+                revisions: {
+                    project: string;
+                    library: string;
+                    agentDefinition: string;
+                    chatProfile: string;
+                };
                 invocationId: string | null;
+                requirement: "required" | "optional";
+                parentInvocationId: string | null;
+                depth: number;
+                requestedAt: string;
+                updatedAt: string;
+                failure: {
+                    code: string;
+                    message: string | null;
+                } | null;
             }[];
-            updatedAt: string;
+            replayed: boolean;
         }>;
     };
     readonly capacity: {
@@ -1068,13 +1147,14 @@ export declare const CONTROL_PLANE_OPERATIONS: {
         readonly discussionResponse: ControlPlaneOperationBinding<{
             assignmentId: string;
         }, {}, {
-            markdown: string;
             leaseToken: string;
             runnerId: string;
             summary?: string | undefined;
             usage?: Record<string, unknown> | undefined;
+            markdown?: string | undefined;
+            outcome?: "responded" | "abstained" | undefined;
         }, {
-            status: "responded";
+            status: "responded" | "abstained";
             schemaVersion: "treeseed.provider-discussion-response-receipt/v1";
             assignmentId: string;
             invocationId: string;

package/dist/operator-contracts/index.d.ts

@@ -7,4 +7,5 @@ export * from './control-plane-operations.js';
 export * from './mcp.js';
 export * from './oauth.js';
 export * from './communication/contracts.js';
+export * from './communication/addressing.js';
 export * from './seed/seed-bundle.js';

package/dist/operator-contracts/index.js

@@ -7,4 +7,5 @@ export * from "./control-plane-operations.js";
 export * from "./mcp.js";
 export * from "./oauth.js";
 export * from "./communication/contracts.js";
+export * from "./communication/addressing.js";
 export * from "./seed/seed-bundle.js";

package/dist/operator-contracts/oauth.d.ts

@@ -1,4 +1,9 @@
 import type { OAuthScope } from './control-plane-operation.js';
+export declare const OAUTH_CLIENT_IDS: {
+    readonly cli: "trsd";
+    readonly admin: "treeseed-admin";
+};
+export type OAuthClientId = typeof OAUTH_CLIENT_IDS[keyof typeof OAUTH_CLIENT_IDS];
 export interface ApiPrincipal {
     id: string;
     displayName?: string;
@@ -18,6 +23,36 @@ export interface OAuthAuthorizationServerMetadata {
     code_challenge_methods_supported: ['S256'];
     scopes_supported: OAuthScope[];
 }
+export interface OAuthAuthorizationPresentation {
+    schemaVersion: 'treeseed.oauth.authorization-presentation/v1';
+    clientId: string;
+    clientName: string;
+    redirectUri: string;
+    redirectOrigin: string;
+    responseType: 'code';
+    codeChallenge: string;
+    codeChallengeMethod: 'S256';
+    scopes: OAuthScope[];
+    state: string | null;
+}
+export interface OAuthAuthorizationDecisionRequest {
+    clientId: string;
+    redirectUri: string;
+    responseType: 'code';
+    codeChallenge: string;
+    codeChallengeMethod: 'S256';
+    scope: OAuthScope[];
+    state?: string | null;
+    decision: 'approve' | 'deny';
+    identifier?: string;
+    password?: string;
+}
+export interface OAuthAuthorizationDecisionResult {
+    schemaVersion: 'treeseed.oauth.authorization-decision/v1';
+    approved: boolean;
+    redirectTo: string;
+    expiresIn?: number;
+}
 export interface OAuthProtectedResourceMetadata {
     resource: string;
     authorization_servers: string[];

package/dist/operator-contracts/oauth.js

@@ -0,0 +1,7 @@
+const OAUTH_CLIENT_IDS = {
+  cli: "trsd",
+  admin: "treeseed-admin"
+};
+export {
+  OAUTH_CLIENT_IDS
+};

package/dist/site-contracts/catalog.d.ts

@@ -0,0 +1,16 @@
+export declare const REMOTE_CONTRACT_HEADER = "x-treeseed-contract-version";
+export declare const REMOTE_CONTRACT_VERSION = 1;
+export declare const COMMERCE_OFFER_MODES: readonly ["free", "private", "contact", "one_time", "one_time_current_version", "subscription", "subscription_updates", "professional_hosting", "scoped_contract", "external"];
+export type CommerceOfferMode = typeof COMMERCE_OFFER_MODES[number];
+export type CatalogItemOfferMode = CommerceOfferMode;
+export interface CatalogItem {
+    id?: string;
+    slug: string;
+    name?: string;
+    title?: string;
+    description?: string;
+    visibility?: string;
+    offerMode?: CommerceOfferMode;
+    priceModel?: CommerceOfferMode;
+    [key: string]: any;
+}

package/dist/site-contracts/catalog.js

@@ -0,0 +1,19 @@
+const REMOTE_CONTRACT_HEADER = "x-treeseed-contract-version";
+const REMOTE_CONTRACT_VERSION = 1;
+const COMMERCE_OFFER_MODES = [
+  "free",
+  "private",
+  "contact",
+  "one_time",
+  "one_time_current_version",
+  "subscription",
+  "subscription_updates",
+  "professional_hosting",
+  "scoped_contract",
+  "external"
+];
+export {
+  COMMERCE_OFFER_MODES,
+  REMOTE_CONTRACT_HEADER,
+  REMOTE_CONTRACT_VERSION
+};

package/dist/site-contracts/cloudflare.d.ts

@@ -0,0 +1,48 @@
+export interface KvNamespacePutOptions {
+    expirationTtl?: number;
+}
+export interface KvNamespaceLike {
+    get(key: string): Promise<string | null>;
+    put(key: string, value: string, options?: KvNamespacePutOptions): Promise<void>;
+}
+export interface D1PreparedStatementLike {
+    bind(...values: unknown[]): D1PreparedStatementLike;
+    run(): Promise<unknown>;
+    first<T = Record<string, unknown>>(): Promise<T | null>;
+    all<T = Record<string, unknown>>(): Promise<{
+        results: T[];
+    }>;
+    raw<T = unknown[]>(): Promise<T[]>;
+}
+export interface D1DatabaseLike {
+    prepare(query: string): D1PreparedStatementLike;
+    batch?(statements: D1PreparedStatementLike[]): Promise<unknown[]>;
+    exec?(query: string): Promise<unknown>;
+}
+export interface CloudflareRuntimeAssets {
+    fetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response>;
+}
+export interface R2ObjectLike {
+    text(): Promise<string>;
+    arrayBuffer(): Promise<ArrayBuffer>;
+    json<T = unknown>(): Promise<T>;
+    httpEtag?: string;
+    etag?: string;
+    size?: number;
+    uploaded?: Date;
+    writeHttpMetadata?(headers: Headers): void;
+}
+export interface R2BucketLike {
+    get(key: string): Promise<R2ObjectLike | null>;
+    head?(key: string): Promise<R2ObjectLike | null>;
+    put(key: string, value: string | ArrayBuffer | ArrayBufferView | ReadableStream, options?: Record<string, unknown>): Promise<unknown>;
+    delete?(key: string | string[]): Promise<void>;
+}
+export interface CloudflareRuntime {
+    env: {
+        FORM_GUARD_KV: KvNamespaceLike;
+        SITE_DATA_DB: D1DatabaseLike;
+        ASSETS?: CloudflareRuntimeAssets;
+        [key: string]: unknown;
+    };
+}

package/dist/site-contracts/platform.d.ts

@@ -0,0 +1,94 @@
+export type ContentCollection = 'pages' | 'notes' | 'questions' | 'objectives' | 'proposals' | 'decisions' | 'people' | 'agents' | 'books' | 'docs' | 'templates' | 'workdays' | 'groups' | 'group_edges';
+export type ThemeMode = 'light' | 'dark' | 'system';
+export type ColorSchemeId = 'fern' | 'lichen' | 'cedar' | 'tidepool' | (string & {});
+export interface SemanticColorTokens {
+    canvas: string;
+    canvasSubtle: string;
+    surface: string;
+    surfaceMuted: string;
+    surfaceRaised: string;
+    surfaceOverlay: string;
+    text: string;
+    textMuted: string;
+    textSubtle: string;
+    textInverse: string;
+    link: string;
+    linkHover: string;
+    border: string;
+    borderMuted: string;
+    borderStrong: string;
+    focus: string;
+    accent: string;
+    accentHover: string;
+    accentStrong: string;
+    accentSoft: string;
+    accentText: string;
+    info: string;
+    infoSoft: string;
+    infoText: string;
+    infoBorder: string;
+    success: string;
+    successSoft: string;
+    successText: string;
+    successBorder: string;
+    warning: string;
+    warningSoft: string;
+    warningText: string;
+    warningBorder: string;
+    danger: string;
+    dangerSoft: string;
+    dangerText: string;
+    dangerBorder: string;
+    shadow: string;
+    grid: string;
+}
+export interface SchemeTokens {
+    light: SemanticColorTokens;
+    dark: SemanticColorTokens;
+}
+export interface ThemeConfig {
+    defaultScheme?: ColorSchemeId;
+    defaultMode?: ThemeMode;
+    schemes?: Record<string, Partial<{
+        light: Partial<SemanticColorTokens>;
+        dark: Partial<SemanticColorTokens>;
+    }>>;
+}
+export type PlatformSurfaceName = 'web' | 'api' | (string & {});
+export type PlatformResourceKind = 'pages' | 'styles' | 'components' | 'routes' | 'middleware' | 'handlers' | 'config';
+export interface PlatformLayerDefinition {
+    root: string;
+    kinds?: PlatformResourceKind[];
+}
+export interface ManagedServiceEnvironmentConfig {
+    baseUrl?: string;
+    domain?: string;
+    serviceName?: string;
+    [key: string]: unknown;
+}
+export interface DeployConfig {
+    content?: Record<string, unknown>;
+    forms?: Record<string, unknown>;
+    surfaces?: Record<string, unknown>;
+    services?: Record<string, unknown>;
+    [key: string]: any;
+}
+export interface TenantConfig {
+    id?: string;
+    name?: string;
+    root?: string;
+    content: Record<string, string | undefined>;
+    features?: Record<string, boolean | undefined>;
+    site?: {
+        models?: Partial<Record<ContentCollection, {
+            rendered?: boolean;
+        }>>;
+    };
+    theme?: ThemeConfig;
+    plugins?: Array<{
+        package: string;
+        enabled?: boolean;
+        config?: Record<string, unknown>;
+    }>;
+    [key: string]: any;
+}

package/dist/site-contracts/plugin.d.ts

@@ -0,0 +1,63 @@
+import type { DeployConfig, PlatformLayerDefinition, PlatformResourceKind, PlatformSurfaceName, TenantConfig } from './platform.js';
+export type RouteOwner = 'market' | 'admin' | 'core';
+export type RouteResponseKind = 'page' | 'message' | 'redirect' | 'data' | 'proxy' | 'action' | 'feed';
+export type RouteArchetype = 'action' | 'auth-form' | 'collection' | 'dashboard' | 'detail' | 'feed' | 'message' | 'profile' | 'reader' | 'redirect' | 'settings' | 'wizard';
+export type RouteNavigationPosture = 'primary' | 'secondary' | 'contextual' | 'hidden';
+export type RouteStatus = 'active' | 'planned' | 'deprecated';
+export interface RouteCapability {
+    id: string;
+    owner: RouteOwner;
+    responseKind: RouteResponseKind;
+    archetype: RouteArchetype;
+    shell: string;
+    template: string;
+    surface: 'auth' | 'public' | 'personal' | 'team' | 'content' | 'system';
+    resourceType: string;
+    accessPolicy: string[];
+    viewModelDependencies: string[];
+    navigation: RouteNavigationPosture;
+    states: Array<'loading' | 'empty' | 'forbidden' | 'unavailable' | 'validation' | 'conflict' | 'retry' | 'success' | 'not-found'>;
+    selector: string;
+    status: RouteStatus;
+    guarantees: string[];
+    description: string;
+    knowledgePageIds?: string[];
+}
+export interface SiteRouteContribution {
+    pattern: string;
+    entrypoint?: string;
+    resourcePath?: string;
+    capability?: RouteCapability;
+}
+export interface SiteExtensionContribution {
+    routes?: SiteRouteContribution[];
+    starlightComponents?: Record<string, string>;
+    customCss?: string[];
+    remarkPlugins?: unknown[];
+    rehypePlugins?: unknown[];
+    envSchema?: Record<string, unknown>;
+    vitePlugins?: unknown[];
+    integrations?: unknown[];
+    routeMiddleware?: unknown[];
+}
+export interface PluginSiteContext {
+    projectRoot: string;
+    tenantConfig: TenantConfig;
+    deployConfig?: DeployConfig;
+    pluginConfig: Record<string, unknown>;
+}
+export interface Plugin {
+    id?: string;
+    provides?: Record<string, unknown>;
+    siteProviders?: Record<string, SiteExtensionContribution | ((context: PluginSiteContext) => SiteExtensionContribution)>;
+    siteHooks?: SiteExtensionContribution | ((context: PluginSiteContext) => SiteExtensionContribution);
+    siteLayers?: PlatformLayerDefinition[] | ((context: PluginSiteContext) => PlatformLayerDefinition[] | undefined);
+    platformLayers?: Array<PlatformLayerDefinition & {
+        surface?: PlatformSurfaceName;
+        kinds?: PlatformResourceKind[];
+    }>;
+    [key: string]: unknown;
+}
+export declare function defineRoute<T extends SiteRouteContribution>(route: T): T;
+export declare function validateRouteCapabilities(routes: readonly SiteRouteContribution[]): readonly SiteRouteContribution[];
+export declare function definePlugin<T extends Plugin>(plugin: T): T;

package/dist/site-contracts/plugin.js

@@ -0,0 +1,26 @@
+function defineRoute(route) {
+  if (!route.pattern.startsWith("/")) throw new Error(`TreeSeed route pattern must start with "/": ${route.pattern}`);
+  if (route.capability && !/^[a-z][a-z0-9.-]+$/u.test(route.capability.id)) throw new Error(`Invalid TreeSeed route capability id: ${route.capability.id}`);
+  return route;
+}
+function validateRouteCapabilities(routes) {
+  const patterns = /* @__PURE__ */ new Set();
+  const ids = /* @__PURE__ */ new Set();
+  for (const route of routes) {
+    defineRoute(route);
+    if (patterns.has(route.pattern)) throw new Error(`Duplicate TreeSeed route pattern: ${route.pattern}`);
+    patterns.add(route.pattern);
+    if (!route.capability) throw new Error(`TreeSeed route ${route.pattern} is missing capability metadata.`);
+    if (ids.has(route.capability.id)) throw new Error(`Duplicate TreeSeed route capability id: ${route.capability.id}`);
+    ids.add(route.capability.id);
+  }
+  return routes;
+}
+function definePlugin(plugin) {
+  return plugin;
+}
+export {
+  definePlugin,
+  defineRoute,
+  validateRouteCapabilities
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@treeseed/sdk",
-  "version": "0.13.0-rc.37",
+  "version": "0.13.0-rc.39",
   "description": "Portable TreeSeed contracts, standards, and typed remote control-plane clients.",
   "license": "Apache-2.0",
   "repository": {
@@ -85,6 +85,30 @@
       "types": "./dist/operator-contracts/index.d.ts",
       "default": "./dist/operator-contracts/index.js"
     },
+    "./guarantees": {
+      "types": "./dist/guarantees/index.d.ts",
+      "default": "./dist/guarantees/index.js"
+    },
+    "./site-contracts/platform": {
+      "types": "./dist/site-contracts/platform.d.ts",
+      "default": "./dist/site-contracts/platform.js"
+    },
+    "./site-contracts/plugin": {
+      "types": "./dist/site-contracts/plugin.d.ts",
+      "default": "./dist/site-contracts/plugin.js"
+    },
+    "./site-contracts/cloudflare": {
+      "types": "./dist/site-contracts/cloudflare.d.ts",
+      "default": "./dist/site-contracts/cloudflare.js"
+    },
+    "./site-contracts/catalog": {
+      "types": "./dist/site-contracts/catalog.d.ts",
+      "default": "./dist/site-contracts/catalog.js"
+    },
+    "./field-aliases": {
+      "types": "./dist/entrypoints/models/field-aliases.d.ts",
+      "default": "./dist/entrypoints/models/field-aliases.js"
+    },
     "./control-plane-client": {
       "types": "./dist/entrypoints/clients/control-plane-client.d.ts",
       "default": "./dist/entrypoints/clients/control-plane-client.js"