@treeseed/sdk 0.13.0-rc.45 → 0.13.0-rc.48

package/dist/development/schemas.d.ts

@@ -3141,9 +3141,269 @@ export declare const developmentCandidateSchema: z.ZodEffects<z.ZodObject<{
     };
     promotable: boolean;
 }>;
+/** Exact, immutable custody record used to promote an already-built candidate. */
+export declare const releaseEvidenceSchema: z.ZodEffects<z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"treeseed.release-evidence/v1">;
+    candidate: z.ZodObject<{
+        id: z.ZodString;
+        receiptDigest: z.ZodString;
+        sourceCommit: z.ZodString;
+        stagingRef: z.ZodString;
+        workflowRunId: z.ZodString;
+        createdAt: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        id: string;
+        createdAt: string;
+        receiptDigest: string;
+        sourceCommit: string;
+        stagingRef: string;
+        workflowRunId: string;
+    }, {
+        id: string;
+        createdAt: string;
+        receiptDigest: string;
+        sourceCommit: string;
+        stagingRef: string;
+        workflowRunId: string;
+    }>;
+    packages: z.ZodArray<z.ZodObject<{
+        projectId: z.ZodString;
+        name: z.ZodString;
+        version: z.ZodString;
+        minimumBump: z.ZodEnum<["none", "patch", "minor", "major"]>;
+    }, "strict", z.ZodTypeAny, {
+        projectId: string;
+        minimumBump: "none" | "patch" | "minor" | "major";
+        name: string;
+        version: string;
+    }, {
+        projectId: string;
+        minimumBump: "none" | "patch" | "minor" | "major";
+        name: string;
+        version: string;
+    }>, "many">;
+    artifacts: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodEnum<["npm-package", "oci-image", "archive", "executable", "sbom", "contract-bundle", "compatibility-attestation", "component-manifest", "compose", "provenance"]>;
+        identity: z.ZodString;
+        digest: z.ZodString;
+        mediaType: z.ZodString;
+        size: z.ZodOptional<z.ZodNumber>;
+    }, "strict", z.ZodTypeAny, {
+        kind: "npm-package" | "oci-image" | "archive" | "executable" | "contract-bundle" | "sbom" | "compatibility-attestation" | "component-manifest" | "compose" | "provenance";
+        id: string;
+        mediaType: string;
+        identity: string;
+        digest: string;
+        size?: number | undefined;
+    }, {
+        kind: "npm-package" | "oci-image" | "archive" | "executable" | "contract-bundle" | "sbom" | "compatibility-attestation" | "component-manifest" | "compose" | "provenance";
+        id: string;
+        mediaType: string;
+        identity: string;
+        digest: string;
+        size?: number | undefined;
+    }>, "many">;
+    contractBundles: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        digest: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        id: string;
+        digest: string;
+    }, {
+        id: string;
+        digest: string;
+    }>, "many">>;
+    compatibilityAttestations: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        contractId: z.ZodString;
+        digest: z.ZodString;
+        compatible: z.ZodLiteral<true>;
+        minimumBump: z.ZodEnum<["none", "patch", "minor", "major"]>;
+    }, "strict", z.ZodTypeAny, {
+        digest: string;
+        contractId: string;
+        compatible: true;
+        minimumBump: "none" | "patch" | "minor" | "major";
+    }, {
+        digest: string;
+        contractId: string;
+        compatible: true;
+        minimumBump: "none" | "patch" | "minor" | "major";
+    }>, "many">>;
+    verification: z.ZodObject<{
+        status: z.ZodLiteral<"passed">;
+        operations: z.ZodArray<z.ZodString, "many">;
+        completedAt: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        status: "passed";
+        operations: string[];
+        completedAt: string;
+    }, {
+        status: "passed";
+        operations: string[];
+        completedAt: string;
+    }>;
+}, "strict", z.ZodTypeAny, {
+    candidate: {
+        id: string;
+        createdAt: string;
+        receiptDigest: string;
+        sourceCommit: string;
+        stagingRef: string;
+        workflowRunId: string;
+    };
+    artifacts: {
+        kind: "npm-package" | "oci-image" | "archive" | "executable" | "contract-bundle" | "sbom" | "compatibility-attestation" | "component-manifest" | "compose" | "provenance";
+        id: string;
+        mediaType: string;
+        identity: string;
+        digest: string;
+        size?: number | undefined;
+    }[];
+    schemaVersion: "treeseed.release-evidence/v1";
+    compatibilityAttestations: {
+        digest: string;
+        contractId: string;
+        compatible: true;
+        minimumBump: "none" | "patch" | "minor" | "major";
+    }[];
+    verification: {
+        status: "passed";
+        operations: string[];
+        completedAt: string;
+    };
+    packages: {
+        projectId: string;
+        minimumBump: "none" | "patch" | "minor" | "major";
+        name: string;
+        version: string;
+    }[];
+    contractBundles: {
+        id: string;
+        digest: string;
+    }[];
+}, {
+    candidate: {
+        id: string;
+        createdAt: string;
+        receiptDigest: string;
+        sourceCommit: string;
+        stagingRef: string;
+        workflowRunId: string;
+    };
+    artifacts: {
+        kind: "npm-package" | "oci-image" | "archive" | "executable" | "contract-bundle" | "sbom" | "compatibility-attestation" | "component-manifest" | "compose" | "provenance";
+        id: string;
+        mediaType: string;
+        identity: string;
+        digest: string;
+        size?: number | undefined;
+    }[];
+    schemaVersion: "treeseed.release-evidence/v1";
+    verification: {
+        status: "passed";
+        operations: string[];
+        completedAt: string;
+    };
+    packages: {
+        projectId: string;
+        minimumBump: "none" | "patch" | "minor" | "major";
+        name: string;
+        version: string;
+    }[];
+    compatibilityAttestations?: {
+        digest: string;
+        contractId: string;
+        compatible: true;
+        minimumBump: "none" | "patch" | "minor" | "major";
+    }[] | undefined;
+    contractBundles?: {
+        id: string;
+        digest: string;
+    }[] | undefined;
+}>, {
+    candidate: {
+        id: string;
+        createdAt: string;
+        receiptDigest: string;
+        sourceCommit: string;
+        stagingRef: string;
+        workflowRunId: string;
+    };
+    artifacts: {
+        kind: "npm-package" | "oci-image" | "archive" | "executable" | "contract-bundle" | "sbom" | "compatibility-attestation" | "component-manifest" | "compose" | "provenance";
+        id: string;
+        mediaType: string;
+        identity: string;
+        digest: string;
+        size?: number | undefined;
+    }[];
+    schemaVersion: "treeseed.release-evidence/v1";
+    compatibilityAttestations: {
+        digest: string;
+        contractId: string;
+        compatible: true;
+        minimumBump: "none" | "patch" | "minor" | "major";
+    }[];
+    verification: {
+        status: "passed";
+        operations: string[];
+        completedAt: string;
+    };
+    packages: {
+        projectId: string;
+        minimumBump: "none" | "patch" | "minor" | "major";
+        name: string;
+        version: string;
+    }[];
+    contractBundles: {
+        id: string;
+        digest: string;
+    }[];
+}, {
+    candidate: {
+        id: string;
+        createdAt: string;
+        receiptDigest: string;
+        sourceCommit: string;
+        stagingRef: string;
+        workflowRunId: string;
+    };
+    artifacts: {
+        kind: "npm-package" | "oci-image" | "archive" | "executable" | "contract-bundle" | "sbom" | "compatibility-attestation" | "component-manifest" | "compose" | "provenance";
+        id: string;
+        mediaType: string;
+        identity: string;
+        digest: string;
+        size?: number | undefined;
+    }[];
+    schemaVersion: "treeseed.release-evidence/v1";
+    verification: {
+        status: "passed";
+        operations: string[];
+        completedAt: string;
+    };
+    packages: {
+        projectId: string;
+        minimumBump: "none" | "patch" | "minor" | "major";
+        name: string;
+        version: string;
+    }[];
+    compatibilityAttestations?: {
+        digest: string;
+        contractId: string;
+        compatible: true;
+        minimumBump: "none" | "patch" | "minor" | "major";
+    }[] | undefined;
+    contractBundles?: {
+        id: string;
+        digest: string;
+    }[] | undefined;
+}>;
 export type DevelopmentRuntime = z.infer<typeof developmentRuntimeSchema>;
 export type DevelopmentTarget = z.infer<typeof developmentTargetSchema>;
 export type DevelopmentSession = z.infer<typeof developmentSessionSchema>;
 export type DevelopmentCandidate = z.infer<typeof developmentCandidateSchema>;
 export type DevelopmentMode = z.infer<typeof developmentModeSchema>;
 export type DevelopmentReaction = z.infer<typeof developmentReactionSchema>;
+export type ReleaseEvidence = z.infer<typeof releaseEvidenceSchema>;

package/dist/development/schemas.js

@@ -140,6 +140,51 @@ const developmentCandidateSchema = z.object({
 }).strict().superRefine((candidate, context) => {
   if (candidate.source.some((source) => source.dirty) && candidate.promotable) context.addIssue({ code: z.ZodIssueCode.custom, path: ["promotable"], message: "Candidates containing dirty source cannot be promotable." });
   if (candidate.verification.status !== "passed" && candidate.promotable) context.addIssue({ code: z.ZodIssueCode.custom, path: ["promotable"], message: "Only verified candidates can be promotable." });
+  if (candidate.promotable && candidate.source.some((source) => !Object.keys(candidate.dependencyGenerations).some((key) => key === source.projectId || key.startsWith(`${source.projectId}.`)))) {
+    context.addIssue({ code: z.ZodIssueCode.custom, path: ["dependencyGenerations"], message: "Promotable candidates must bind a completed generation for every source project." });
+  }
+});
+const releaseArtifactSchema = z.object({
+  id: identifier,
+  kind: z.enum(["npm-package", "oci-image", "archive", "executable", "sbom", "contract-bundle", "compatibility-attestation", "component-manifest", "compose", "provenance"]),
+  identity: z.string().min(1).max(2048),
+  digest,
+  mediaType: z.string().min(1).max(256),
+  size: z.number().int().nonnegative().optional()
+}).strict();
+const releaseEvidenceSchema = z.object({
+  schemaVersion: z.literal("treeseed.release-evidence/v1"),
+  candidate: z.object({
+    id: identifier,
+    receiptDigest: digest,
+    sourceCommit: gitCommit,
+    stagingRef: z.string().min(1).max(256),
+    workflowRunId: z.string().regex(/^[1-9][0-9]*$/u),
+    createdAt: z.string().datetime()
+  }).strict(),
+  packages: z.array(z.object({
+    projectId: identifier,
+    name: z.string().min(1).max(256),
+    version: z.string().min(1).max(128),
+    minimumBump: z.enum(["none", "patch", "minor", "major"])
+  }).strict()).min(1),
+  artifacts: z.array(releaseArtifactSchema).min(1),
+  contractBundles: z.array(z.object({ id: identifier, digest }).strict()).default([]),
+  compatibilityAttestations: z.array(z.object({ contractId: z.string().min(1), digest, compatible: z.literal(true), minimumBump: z.enum(["none", "patch", "minor", "major"]) }).strict()).default([]),
+  verification: z.object({
+    status: z.literal("passed"),
+    operations: z.array(z.string().min(1)).min(1),
+    completedAt: z.string().datetime()
+  }).strict()
+}).strict().superRefine((evidence, context) => {
+  const identities = evidence.artifacts.map((artifact) => artifact.identity);
+  if (new Set(identities).size !== identities.length) context.addIssue({ code: z.ZodIssueCode.custom, path: ["artifacts"], message: "Release artifact identities must be unique." });
+  for (const bundle of evidence.contractBundles) {
+    if (!evidence.artifacts.some((artifact) => artifact.kind === "contract-bundle" && artifact.digest === bundle.digest)) context.addIssue({ code: z.ZodIssueCode.custom, path: ["contractBundles"], message: `Contract bundle ${bundle.id} is not present in artifact custody.` });
+  }
+  for (const attestation of evidence.compatibilityAttestations) {
+    if (!evidence.artifacts.some((artifact) => artifact.kind === "compatibility-attestation" && artifact.digest === attestation.digest)) context.addIssue({ code: z.ZodIssueCode.custom, path: ["compatibilityAttestations"], message: `Compatibility attestation ${attestation.contractId} is not present in artifact custody.` });
+  }
 });
 export {
   developmentCandidateSchema,
@@ -149,5 +194,6 @@ export {
   developmentSessionSchema,
   developmentStatePolicySchema,
   developmentTargetKindSchema,
-  developmentTargetSchema
+  developmentTargetSchema,
+  releaseEvidenceSchema
 };

package/dist/operator-contracts/canonical-command-tree.js

@@ -8,6 +8,7 @@ const local = (handlerId) => ({ kind: "local", handlerId });
 const field = (target, name, source, sourceName = name, required = false, transform = "identity") => ({ target, field: name, source, name: sourceName, required, transform });
 const operation = (operationId, input = []) => ({ kind: "operation", operationId, input });
 const page = () => [field("query", "status", "option"), field("query", "limit", "option", "limit", false, "integer"), field("query", "cursor", "option")];
+const aiNode = () => field("path", "nodeId", "context", "node", true);
 const operationBindings = {
   "auth login": protocol("protocol.oauth.device.login"),
   "auth logout": protocol("protocol.oauth.revoke"),
@@ -110,6 +111,21 @@ const operationBindings = {
   "projects treedx workspaces list": operation("treedx.workspaces.list", [field("path", "projectId", "argument", "project", true), ...page()]),
   "projects treedx workspaces show": operation("treedx.workspaces.show", [field("path", "projectId", "context", "project", true), field("path", "workspaceId", "argument", "workspace", true)]),
   "projects treedx workspaces abandon": operation("treedx.workspaces.abandon", [field("path", "projectId", "context", "project", true), field("path", "workspaceId", "argument", "workspace", true)]),
+  "ai status": operation("treeai.qualification.get.status", [aiNode()]),
+  "ai mode show": operation("treeai.qualification.get.mode", [aiNode()]),
+  "ai mode set": operation("treeai.qualification.post.mode", [aiNode(), field("body", "mode", "argument", "mode", true)]),
+  "ai inference models": operation("treeai.inference.get.models", [aiNode()]),
+  "ai inference jobs": operation("treeai.inference.get.jobs", [aiNode()]),
+  "ai inference rollback": operation("treeai.inference.post.deployments.rollback", [aiNode()]),
+  "ai training libraries": operation("treeai.training.get.libraries", [aiNode()]),
+  "ai training jobs": operation("treeai.training.get.jobs", [aiNode()]),
+  "ai training runs": operation("treeai.training.get.library.runs", [aiNode()]),
+  "ai lab status": operation("treeai.lab.get.status", [aiNode()]),
+  "ai lab agents": operation("treeai.lab.get.agents", [aiNode()]),
+  "ai lab libraries": operation("treeai.lab.get.libraries", [aiNode()]),
+  "ai qualify status": operation("treeai.qualification.get.qualification.profile", [aiNode()]),
+  "ai qualify run": operation("treeai.qualification.post.qualification.campaigns", [aiNode()]),
+  "ai qualify campaigns": operation("treeai.qualification.get.qualification.campaigns", [aiNode()]),
   "library show": local("local.library.show"),
   "library status": local("local.library.status"),
   "library paths": local("local.library.paths"),
@@ -299,6 +315,14 @@ const commandTree = {
       leaf("capabilities", "read", "project"),
       branch("workspaces", [leaf("list", "read", "project"), leaf("show", "read", "workspace"), leaf("abandon", "mutation", "workspace", "destructive")])
     ])]),
+    branch("ai", [
+      leaf("status"),
+      branch("mode", [leaf("show"), leaf("set", "mutation", "mode", "authority")]),
+      branch("inference", [leaf("models"), leaf("jobs"), leaf("rollback", "mutation", void 0, "destructive")]),
+      branch("training", [leaf("libraries"), leaf("jobs"), leaf("runs")]),
+      branch("lab", [leaf("status"), leaf("agents"), leaf("libraries")]),
+      branch("qualify", [leaf("status"), leaf("run", "mutation", void 0, "authority"), leaf("campaigns")])
+    ]),
     branch("library", [
       libraryRead("show"),
       libraryRead("status"),

package/dist/operator-contracts/catalog/treeai-operations.d.ts

@@ -0,0 +1,14 @@
+import type { ControlPlaneOperationBinding } from '../control-plane-operation.js';
+export declare const TREEAI_OPENAPI_DIGESTS: {
+    readonly inference: "sha256:3a00f1d91635d87d0aad2c6d329f495ff210f393bc9851570aa3e3ad1f5c1db4";
+    readonly training: "sha256:89dc70cecc85079853e4f177827d681e66f4b24b93ef17713051b99f07c2fe00";
+    readonly lab: "sha256:bccafa27b00a63b9fb22b132b850f9af6e77d44047dbc8966344088266d65898";
+    readonly qualification: "sha256:3f68b78845ec19c5de389663f1cb677ab4df0683ecd113c4f5780885a89370b7";
+};
+export declare const TREEAI_CONTROL_PLANE_OPERATION_LIST: readonly ControlPlaneOperationBinding<{
+    nodeId: string;
+}, {}, Record<string, unknown> | undefined, Record<string, unknown>>[];
+export declare const TREEAI_CONTROL_PLANE_OPERATIONS: Readonly<Record<string, ControlPlaneOperationBinding<any, any, any, any>>>;
+export declare function treeAiControlPlaneOperation(upstreamOperationId: string): ControlPlaneOperationBinding<{
+    nodeId: string;
+}, {}, Record<string, unknown> | undefined, Record<string, unknown>>;

package/dist/operator-contracts/catalog/treeai-operations.js

@@ -0,0 +1,62 @@
+import { z } from "zod";
+import { defineOperation } from "../operation-builder.js";
+import { TREEAI_UPSTREAM_OPERATIONS } from "../../treeai/generated/upstream.js";
+const TREEAI_OPENAPI_DIGESTS = {
+  inference: "sha256:3a00f1d91635d87d0aad2c6d329f495ff210f393bc9851570aa3e3ad1f5c1db4",
+  training: "sha256:89dc70cecc85079853e4f177827d681e66f4b24b93ef17713051b99f07c2fe00",
+  lab: "sha256:bccafa27b00a63b9fb22b132b850f9af6e77d44047dbc8966344088266d65898",
+  qualification: "sha256:3f68b78845ec19c5de389663f1cb677ab4df0683ecd113c4f5780885a89370b7"
+};
+function treeSeedOperationId(operation) {
+  return `treeai.${operation.operationId.toLowerCase().replace(/[^a-z0-9]+/gu, ".").replace(/^\.|\.$/gu, "")}`;
+}
+function risk(operation) {
+  if (/rollback|cancel|disable/u.test(operation.operationId)) return "destructive";
+  if (operation.kind === "mutation" && (/promot|enable|activate|campaigns/u.test(operation.operationId) || /(?:^|\.)mode(?:\.|$)/u.test(operation.operationId))) return "authority";
+  return "ordinary";
+}
+function pathShape(path) {
+  return Object.fromEntries([...path.matchAll(/\{([^}]+)\}/gu)].map((match) => [match[1], z.string().min(1)]));
+}
+function binding(operation) {
+  const method = operation.method;
+  const kind = operation.kind;
+  const riskClass = risk(operation);
+  const path = `/v1/ai/nodes/{nodeId}/${operation.service}${operation.path}`;
+  return defineOperation({
+    operationId: treeSeedOperationId(operation),
+    description: `${operation.summary} through a node-scoped TreeAI proxy.`,
+    rest: { method, path },
+    parameters: `treeseed.${treeSeedOperationId(operation)}.parameters/v1`,
+    capability: `treeai.${operation.service}.${kind}`,
+    authentication: "oauth_or_provider",
+    oauthScopes: kind === "read" ? ["treeseed:read"] : ["treeseed:execution"],
+    kind,
+    riskClass,
+    confirmation: riskClass === "ordinary" ? "never" : "input_required",
+    idempotencyRequired: kind === "mutation",
+    surfaces: ["rest", "cli"],
+    cacheScope: kind === "read" ? "principal" : "none",
+    pagination: "none",
+    redactedPaths: ["headers.authorization"],
+    upstream: { service: "treeai", operationId: operation.operationId, contractVersion: "3.1.1", contractDigest: TREEAI_OPENAPI_DIGESTS[operation.service] }
+  }, {
+    path: z.object({ nodeId: z.string().min(1), ...pathShape(operation.path) }).strict(),
+    query: kind === "read" ? z.record(z.unknown()) : z.object({}).strict(),
+    body: kind === "read" ? z.undefined() : z.record(z.unknown()),
+    output: z.record(z.unknown())
+  });
+}
+const TREEAI_CONTROL_PLANE_OPERATION_LIST = Object.freeze(TREEAI_UPSTREAM_OPERATIONS.map(binding));
+const TREEAI_CONTROL_PLANE_OPERATIONS = Object.freeze(Object.fromEntries(TREEAI_CONTROL_PLANE_OPERATION_LIST.map((item) => [item.descriptor.operationId, item])));
+function treeAiControlPlaneOperation(upstreamOperationId) {
+  const operation = TREEAI_CONTROL_PLANE_OPERATION_LIST.find((item) => item.descriptor.upstream?.operationId === upstreamOperationId);
+  if (!operation) throw new Error(`Unknown TreeAI operation ${upstreamOperationId}.`);
+  return operation;
+}
+export {
+  TREEAI_CONTROL_PLANE_OPERATIONS,
+  TREEAI_CONTROL_PLANE_OPERATION_LIST,
+  TREEAI_OPENAPI_DIGESTS,
+  treeAiControlPlaneOperation
+};

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

@@ -28,7 +28,7 @@ export interface ControlPlaneConcurrencyContract {
     writeHeader: 'If-Match';
 }
 export interface ControlPlaneUpstreamBinding {
-    service: 'treedx';
+    service: 'treedx' | 'treeai';
     operationId: string;
     contractVersion: string;
     contractDigest: `sha256:${string}`;

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

@@ -1,5 +1,6 @@
 import { type ControlPlaneOperationBinding, type ControlPlaneOperationDescriptor } from './control-plane-operation.js';
 export declare const CONTROL_PLANE_OPERATIONS: {
+    readonly treeai: Readonly<Record<string, ControlPlaneOperationBinding<any, any, any, any>>>;
     readonly status: {
         readonly show: ControlPlaneOperationBinding<{}, {}, undefined, Record<string, unknown>>;
     };
@@ -999,8 +1000,8 @@ export declare const CONTROL_PLANE_OPERATIONS: {
             }, {}, Record<string, unknown> | undefined, Record<string, unknown>>;
             readonly node: ControlPlaneOperationBinding<{
                 projectId: string;
-                repoId: string;
                 nodeId: string;
+                repoId: string;
             }, {}, Record<string, unknown> | undefined, Record<string, unknown>>;
             readonly related: ControlPlaneOperationBinding<{
                 projectId: string;

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

@@ -2,6 +2,7 @@ import { z } from "zod";
 import { defineOperation as define, defineTreeDxProxyOperation as treedxProxy } from "./operation-builder.js";
 import { communicationOperations, providerDiscussionResponseOperation } from "./catalog/communication-operations.js";
 import { adminAccountOperations, adminTeamOperations } from "./catalog/admin-account-team-operations.js";
+import { TREEAI_CONTROL_PLANE_OPERATIONS } from "./catalog/treeai-operations.js";
 const empty = z.object({}).strict();
 const none = z.undefined();
 const record = z.record(z.unknown());
@@ -96,6 +97,7 @@ function resource(operationId, method, path, pathShape, options = { capability:
   }, { path: z.object(pathShape).strict(), query: kind === "read" ? record : empty, body: kind === "read" ? none : record, output: payload });
 }
 const CONTROL_PLANE_OPERATIONS = {
+  treeai: TREEAI_CONTROL_PLANE_OPERATIONS,
   status: {
     show: read("status.show", "/v1/status", "status.read", ["rest", "cli", "mcp_tool", "mcp_resource"])
   },

package/dist/treeai/catalog.d.ts

@@ -0,0 +1 @@
+export * from '../operator-contracts/catalog/treeai-operations.js';

package/dist/treeai/catalog.js

@@ -0,0 +1 @@
+export * from "../operator-contracts/catalog/treeai-operations.js";