@treeseed/sdk 0.12.62 → 0.13.0-rc.10

package/dist/standards/typescript/extract.d.ts

@@ -0,0 +1,10 @@
+import type { TypeScriptApiModel } from './contracts.js';
+export interface TypeScriptDeclarationEntrypointInput {
+    specifier: string;
+    declarationPath: string;
+    source: string;
+}
+export interface TypeScriptExtractionOptions {
+    unresolvedLocalSymbols?: 'error' | 'record';
+}
+export declare function extractTypeScriptApi(input: TypeScriptDeclarationEntrypointInput[], declarations?: Readonly<Record<string, string>>, options?: TypeScriptExtractionOptions): TypeScriptApiModel;

package/dist/standards/typescript/extract.js

@@ -0,0 +1,244 @@
+import ts from "typescript";
+function normalizedText(node, sourceFile) {
+  return node.getText(sourceFile).replace(/\s+/gu, " ").trim();
+}
+function deprecated(node) {
+  return ts.getJSDocTags(node).some((tag) => tag.tagName.text === "deprecated");
+}
+function exported(node) {
+  return ts.canHaveModifiers(node) && ts.getModifiers(node)?.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword) === true;
+}
+function normalizeDeclarationPath(value) {
+  const normalized = [];
+  for (const segment of value.replaceAll("\\", "/").split("/")) {
+    if (!segment || segment === ".") continue;
+    if (segment === "..") normalized.pop();
+    else normalized.push(segment);
+  }
+  return normalized.join("/");
+}
+function resolveLocalDeclaration(fromPath, specifier) {
+  if (!specifier.startsWith(".")) return null;
+  const directory = fromPath.includes("/") ? fromPath.slice(0, fromPath.lastIndexOf("/")) : "";
+  const resolved = normalizeDeclarationPath(`${directory}/${specifier}`);
+  if (/\.d\.(?:mts|cts|ts)$/u.test(resolved)) return resolved;
+  if (/\.(?:mjs|cjs|js)$/u.test(resolved)) return resolved.replace(/\.(?:mjs|cjs|js)$/u, ".d.ts");
+  return `${resolved}.d.ts`;
+}
+function memberName(node, sourceFile) {
+  return node.name ? normalizedText(node.name, sourceFile).replace(/^['"]|['"]$/gu, "") : null;
+}
+function member(node, sourceFile) {
+  if (!ts.isPropertySignature(node) && !ts.isPropertyDeclaration(node) && !ts.isMethodSignature(node) && !ts.isMethodDeclaration(node)) return null;
+  const name = memberName(node, sourceFile);
+  if (!name) return null;
+  const type = ts.isMethodSignature(node) || ts.isMethodDeclaration(node) ? normalizedText(node, sourceFile).replace(/^[^(]+/u, "") : node.type ? normalizedText(node.type, sourceFile) : "unknown";
+  return {
+    name,
+    type,
+    optional: Boolean(node.questionToken),
+    readonly: ts.canHaveModifiers(node) && ts.getModifiers(node)?.some((modifier) => modifier.kind === ts.SyntaxKind.ReadonlyKeyword) === true,
+    deprecated: deprecated(node)
+  };
+}
+function parameter(node, sourceFile) {
+  return {
+    name: normalizedText(node.name, sourceFile),
+    type: node.type ? normalizedText(node.type, sourceFile) : "unknown",
+    optional: Boolean(node.questionToken || node.initializer),
+    rest: Boolean(node.dotDotDotToken)
+  };
+}
+function functionSignature(node, sourceFile) {
+  const typeParameters = node.typeParameters?.length ? `<${node.typeParameters.map((entry) => normalizedText(entry, sourceFile)).join(",")}>` : "";
+  const parameters = node.parameters.map((entry) => {
+    const value = parameter(entry, sourceFile);
+    return `${value.rest ? "..." : ""}${value.type}${value.optional ? "?" : ""}`;
+  }).join(",");
+  return `${typeParameters}(${parameters}):${node.type ? normalizedText(node.type, sourceFile) : "unknown"}`;
+}
+function heritage(node, sourceFile) {
+  return (node.heritageClauses ?? []).flatMap((clause) => clause.types.map(
+    (entry) => `${clause.token === ts.SyntaxKind.ExtendsKeyword ? "extends" : "implements"}:${normalizedText(entry, sourceFile)}`
+  )).sort();
+}
+function symbol(node, sourceFile, requireExport = true) {
+  if (requireExport && !exported(node)) return null;
+  if (ts.isFunctionDeclaration(node) && node.name) return {
+    name: node.name.text,
+    kind: "function",
+    deprecated: deprecated(node),
+    heritage: [],
+    members: [],
+    parameters: node.parameters.map((entry) => parameter(entry, sourceFile)),
+    returnType: node.type ? normalizedText(node.type, sourceFile) : "unknown",
+    signatures: [functionSignature(node, sourceFile)],
+    definition: null
+  };
+  if (ts.isInterfaceDeclaration(node) || ts.isClassDeclaration(node)) {
+    const declarationName = node.name?.text;
+    if (!declarationName) return null;
+    return {
+      name: declarationName,
+      kind: ts.isInterfaceDeclaration(node) ? "interface" : "class",
+      deprecated: deprecated(node),
+      heritage: heritage(node, sourceFile),
+      members: node.members.map((entry) => member(entry, sourceFile)).filter((entry) => Boolean(entry)).sort((left, right) => `${left.name}:${left.type}`.localeCompare(`${right.name}:${right.type}`)),
+      parameters: [],
+      returnType: null,
+      signatures: [],
+      definition: null
+    };
+  }
+  if (ts.isTypeAliasDeclaration(node)) return {
+    name: node.name.text,
+    kind: "type",
+    deprecated: deprecated(node),
+    heritage: [],
+    members: [],
+    parameters: [],
+    returnType: null,
+    signatures: [],
+    definition: normalizedText(node.type, sourceFile)
+  };
+  if (ts.isEnumDeclaration(node)) return {
+    name: node.name.text,
+    kind: "enum",
+    deprecated: deprecated(node),
+    heritage: [],
+    members: [],
+    parameters: [],
+    returnType: null,
+    signatures: [],
+    definition: node.members.map((entry) => normalizedText(entry, sourceFile)).join("|")
+  };
+  if (ts.isVariableStatement(node)) {
+    const declaration = node.declarationList.declarations[0];
+    if (!declaration || !ts.isIdentifier(declaration.name)) return null;
+    return {
+      name: declaration.name.text,
+      kind: "variable",
+      deprecated: deprecated(node),
+      heritage: [],
+      members: [],
+      parameters: [],
+      returnType: null,
+      signatures: [],
+      definition: declaration.type ? normalizedText(declaration.type, sourceFile) : "unknown"
+    };
+  }
+  return null;
+}
+function externalReexport(moduleName, exportedName) {
+  return {
+    name: exportedName,
+    kind: "variable",
+    deprecated: false,
+    heritage: [],
+    members: [],
+    parameters: [],
+    returnType: null,
+    signatures: [],
+    definition: `external-reexport:${moduleName}`
+  };
+}
+function extractEntrypoint(input, declarations, options) {
+  const cache = /* @__PURE__ */ new Map();
+  const active = /* @__PURE__ */ new Set();
+  function extractFile(declarationPath) {
+    const normalizedPath = normalizeDeclarationPath(declarationPath);
+    const cached = cache.get(normalizedPath);
+    if (cached) return cached;
+    if (active.has(normalizedPath)) return /* @__PURE__ */ new Map();
+    const source = declarations[normalizedPath];
+    if (source === void 0) throw new Error(`Unresolved local public declaration: ${normalizedPath}.`);
+    active.add(normalizedPath);
+    const sourceFile = ts.createSourceFile(normalizedPath, source, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+    const collected = /* @__PURE__ */ new Map();
+    const local = /* @__PURE__ */ new Map();
+    function collect(target, value) {
+      const previous = target.get(value.name);
+      if (previous?.kind === "function" && value.kind === "function") {
+        target.set(value.name, { ...previous, signatures: [.../* @__PURE__ */ new Set([...previous.signatures, ...value.signatures])].sort() });
+        return;
+      }
+      target.set(value.name, value);
+    }
+    const imported = /* @__PURE__ */ new Map();
+    for (const statement of sourceFile.statements) {
+      if (ts.isImportDeclaration(statement) && statement.importClause && ts.isStringLiteral(statement.moduleSpecifier)) {
+        const moduleName = statement.moduleSpecifier.text;
+        const localTarget = resolveLocalDeclaration(normalizedPath, moduleName);
+        if (statement.importClause.name) {
+          imported.set(statement.importClause.name.text, { moduleName, sourceName: "default", localTarget });
+        }
+        const bindings = statement.importClause.namedBindings;
+        if (bindings && ts.isNamespaceImport(bindings)) {
+          imported.set(bindings.name.text, { moduleName, sourceName: "*", localTarget });
+        } else if (bindings) {
+          for (const element of bindings.elements) {
+            imported.set(element.name.text, {
+              moduleName,
+              sourceName: element.propertyName?.text ?? element.name.text,
+              localTarget
+            });
+          }
+        }
+      }
+      const localSymbol = symbol(statement, sourceFile, false);
+      if (localSymbol) collect(local, localSymbol);
+      const publicSymbol = symbol(statement, sourceFile);
+      if (publicSymbol) collect(collected, publicSymbol);
+    }
+    for (const statement of sourceFile.statements) {
+      if (!ts.isExportDeclaration(statement)) continue;
+      const moduleName = statement.moduleSpecifier && ts.isStringLiteral(statement.moduleSpecifier) ? statement.moduleSpecifier.text : null;
+      const localTarget = moduleName ? resolveLocalDeclaration(normalizedPath, moduleName) : null;
+      const targetSymbols = localTarget ? extractFile(localTarget) : moduleName ? null : local;
+      if (!statement.exportClause) {
+        if (targetSymbols) {
+          for (const [name, exportedSymbol] of targetSymbols) if (name !== "default") collected.set(name, exportedSymbol);
+        } else if (moduleName) {
+          collected.set(`* from ${moduleName}`, externalReexport(moduleName, `* from ${moduleName}`));
+        }
+        continue;
+      }
+      if (ts.isNamespaceExport(statement.exportClause)) {
+        const name = statement.exportClause.name.text;
+        collected.set(name, externalReexport(moduleName ?? normalizedPath, name));
+        continue;
+      }
+      for (const element of statement.exportClause.elements) {
+        const sourceName = element.propertyName?.text ?? element.name.text;
+        const exportedName = element.name.text;
+        let target = targetSymbols?.get(sourceName);
+        if (!target && !moduleName) {
+          const importedBinding = imported.get(sourceName);
+          if (importedBinding?.localTarget) {
+            target = extractFile(importedBinding.localTarget).get(importedBinding.sourceName);
+          } else if (importedBinding) {
+            target = externalReexport(importedBinding.moduleName, exportedName);
+          }
+        }
+        if (target) collected.set(exportedName, { ...target, name: exportedName });
+        else if (moduleName && !localTarget) collected.set(exportedName, externalReexport(moduleName, exportedName));
+        else if (options.unresolvedLocalSymbols === "record") collected.set(exportedName, {
+          ...externalReexport(normalizedPath, exportedName),
+          definition: `unresolved-local-reexport:${normalizedPath}:${sourceName}`
+        });
+        else throw new Error(`Unresolved public symbol ${sourceName} in ${normalizedPath}.`);
+      }
+    }
+    active.delete(normalizedPath);
+    cache.set(normalizedPath, collected);
+    return collected;
+  }
+  const symbols = [...extractFile(input.declarationPath).values()].sort((left, right) => left.name.localeCompare(right.name));
+  return { specifier: input.specifier, declarationPath: normalizeDeclarationPath(input.declarationPath), symbols };
+}
+function extractTypeScriptApi(input, declarations = Object.fromEntries(input.map((entry) => [normalizeDeclarationPath(entry.declarationPath), entry.source])), options = {}) {
+  return { schemaVersion: 1, entrypoints: input.map((entry) => extractEntrypoint(entry, declarations, options)).sort((left, right) => left.specifier.localeCompare(right.specifier)) };
+}
+export {
+  extractTypeScriptApi
+};

package/dist/standards/typescript/index.d.ts

@@ -0,0 +1,3 @@
+export * from './compare.js';
+export * from './contracts.js';
+export * from './extract.js';

package/dist/standards/typescript/index.js

@@ -0,0 +1,3 @@
+export * from "./compare.js";
+export * from "./contracts.js";
+export * from "./extract.js";

package/dist/treedx/accounts/auth.d.ts

@@ -0,0 +1,17 @@
+export interface TreeDxHs256TokenInput {
+    secret: string;
+    issuer: string;
+    audience: string;
+    actorId: string;
+    tenantId: string;
+    repoIds?: string[];
+    capabilities?: string[];
+    refs?: string[];
+    paths?: string[];
+    projectId?: string;
+    capacityWorkdayRunId?: string;
+    ttlSeconds?: number;
+    nowEpochSeconds?: number;
+    jti?: string;
+}
+export declare function mintTreeDxHs256Token(input: TreeDxHs256TokenInput): string;

package/dist/treedx/accounts/auth.js

@@ -0,0 +1,48 @@
+import { createHmac, randomUUID } from "node:crypto";
+function required(value, owner) {
+  const normalized = value.trim();
+  if (!normalized) throw new Error(`${owner} is required to mint a TreeDX token.`);
+  return normalized;
+}
+function normalizedStrings(values, fallback) {
+  const normalized = values?.map((value) => String(value).trim()).filter(Boolean) ?? [];
+  return normalized.length > 0 ? [...new Set(normalized)] : fallback;
+}
+function base64urlJson(value) {
+  return Buffer.from(JSON.stringify(value)).toString("base64url");
+}
+function mintTreeDxHs256Token(input) {
+  const secret = required(input.secret, "secret");
+  const issuer = required(input.issuer, "issuer");
+  const audience = required(input.audience, "audience");
+  const actorId = required(input.actorId, "actorId");
+  const tenantId = required(input.tenantId, "tenantId");
+  const ttlSeconds = input.ttlSeconds ?? 300;
+  if (!Number.isInteger(ttlSeconds) || ttlSeconds < 30 || ttlSeconds > 3600) {
+    throw new Error("ttlSeconds must be an integer between 30 and 3600.");
+  }
+  const now = input.nowEpochSeconds ?? Math.floor(Date.now() / 1e3);
+  if (!Number.isInteger(now) || now < 0) throw new Error("nowEpochSeconds must be a nonnegative integer.");
+  const payload = {
+    iss: issuer,
+    aud: audience,
+    sub: actorId,
+    jti: input.jti?.trim() || randomUUID(),
+    iat: now,
+    nbf: now - 5,
+    exp: now + ttlSeconds,
+    treedx_actor_id: actorId,
+    treedx_tenant_id: tenantId,
+    treedx_repo_ids: normalizedStrings(input.repoIds, ["*"]),
+    treedx_capabilities: normalizedStrings(input.capabilities, []),
+    treedx_refs: normalizedStrings(input.refs, ["*"]),
+    treedx_paths: normalizedStrings(input.paths, ["**"]),
+    ...input.projectId?.trim() ? { treeseed_project_id: input.projectId.trim() } : {},
+    ...input.capacityWorkdayRunId?.trim() ? { treeseed_capacity_workday_run_id: input.capacityWorkdayRunId.trim() } : {}
+  };
+  const signingInput = `${base64urlJson({ alg: "HS256", typ: "JWT" })}.${base64urlJson(payload)}`;
+  return `${signingInput}.${createHmac("sha256", secret).update(signingInput).digest("base64url")}`;
+}
+export {
+  mintTreeDxHs256Token
+};

package/dist/treedx/client/accounts/contracts/auth-mode.d.ts

@@ -0,0 +1,3 @@
+import { TreeDxClient } from "../../../support/client.js";
+import type { TreeDxAuthMode } from "../../../types.js";
+export declare function authModeMethod(this: TreeDxClient): Promise<TreeDxAuthMode>;

package/dist/treedx/client/accounts/contracts/auth-mode.js

@@ -0,0 +1,6 @@
+function authModeMethod() {
+  return this.request("GET", "/api/v1/auth/mode");
+}
+export {
+  authModeMethod
+};

package/dist/treedx/client/build/creation/build-context.d.ts

@@ -0,0 +1,3 @@
+import { TreeDxClient } from '../../../support/client.js';
+import type { TreeDxContextRequest, TreeDxContextResult } from '../../../types.js';
+export declare function buildContextMethod(this: TreeDxClient, input: TreeDxContextRequest): Promise<TreeDxContextResult>;

package/dist/treedx/client/build/creation/build-context.js

@@ -0,0 +1,7 @@
+function buildContextMethod(input) {
+  const { repoId, ...body } = input;
+  return this.request("POST", `/api/v1/repos/${encodeURIComponent(this.repoId(repoId))}/context/build`, body, { tokenRequired: true });
+}
+export {
+  buildContextMethod
+};

package/dist/treedx/client/build/creation/build-snapshot.d.ts

@@ -0,0 +1,3 @@
+import { TreeDxClient } from '../../../support/client.js';
+import type { TreeDxSnapshot, TreeDxSnapshotBuildRequest } from '../../../types.js';
+export declare function buildSnapshotMethod(this: TreeDxClient, input?: TreeDxSnapshotBuildRequest): Promise<TreeDxSnapshot>;

package/dist/treedx/client/build/creation/build-snapshot.js

@@ -0,0 +1,8 @@
+import { firstPayload } from "../../../support/client.js";
+function buildSnapshotMethod(input = {}) {
+  const { repoId, ...body } = input;
+  return this.request("POST", `/api/v1/repos/${encodeURIComponent(this.repoId(repoId))}/snapshots/build`, body, { tokenRequired: true }).then((payload) => firstPayload(payload, ["snapshot"]));
+}
+export {
+  buildSnapshotMethod
+};

package/dist/treedx/client/capacity/allocations/contracts/put-capability-grant.d.ts

@@ -0,0 +1,3 @@
+import { TreeDxClient } from "../../../../support/client.js";
+import type { TreeDxCapabilityGrant } from "../../../../types.js";
+export declare function putCapabilityGrantMethod(this: TreeDxClient, input: TreeDxCapabilityGrant): Promise<TreeDxCapabilityGrant>;

package/dist/treedx/client/capacity/allocations/contracts/put-capability-grant.js

@@ -0,0 +1,7 @@
+import { firstPayload } from "../../../../support/client.js";
+function putCapabilityGrantMethod(input) {
+  return this.request("POST", "/api/v1/policy/grants", input, { tokenRequired: true }).then((payload) => firstPayload(payload, ["grant"]));
+}
+export {
+  putCapabilityGrantMethod
+};

package/dist/treedx/client/capacity/allocations/queries/list-capability-grants.d.ts

@@ -0,0 +1,6 @@
+import { TreeDxClient } from "../../../../support/client.js";
+import type { TreeDxCapabilityGrant } from "../../../../types.js";
+export declare function listCapabilityGrantsMethod(this: TreeDxClient, input?: {
+    actorId?: string;
+    repoId?: string;
+}): Promise<TreeDxCapabilityGrant[]>;

package/dist/treedx/client/capacity/allocations/queries/list-capability-grants.js

@@ -0,0 +1,10 @@
+import { firstPayload } from "../../../../support/client.js";
+function listCapabilityGrantsMethod(input = {}) {
+  return this.request("GET", "/api/v1/policy/grants", void 0, {
+    query: input,
+    tokenRequired: true
+  }).then((payload) => firstPayload(payload, ["grants"]));
+}
+export {
+  listCapabilityGrantsMethod
+};

package/dist/treedx/client/methods.d.ts

@@ -0,0 +1,102 @@
+export { authModeMethod } from './accounts/contracts/auth-mode.js';
+export { buildContextMethod } from './build/creation/build-context.js';
+export { buildSnapshotMethod } from './build/creation/build-snapshot.js';
+export { putCapabilityGrantMethod } from './capacity/allocations/contracts/put-capability-grant.js';
+export { listCapabilityGrantsMethod } from './capacity/allocations/queries/list-capability-grants.js';
+export { restoreStorageMethod } from './persistence/contracts/restore-storage.js';
+export { verifyStorageRestoreMethod } from './persistence/lifecycle/verify-storage-restore.js';
+export { registerRepositoryMethod } from './repositories/creation/register-repository.js';
+export { getRepositoryMethod } from './repositories/queries/get-repository.js';
+export { listRepositoryRefsMethod } from './repositories/queries/list-repository-refs.js';
+export { listRepositoryPathsMethod } from './repositories/queries/list-repository-paths.js';
+export { queryRepositoryMethod } from './repositories/queries/query-repository.js';
+export { readRepositoryFileMethod } from './repositories/queries/read-repository-file.js';
+export { readRepositoryFilesMethod } from './repositories/queries/read-repository-files.js';
+export { searchRepositoryFilesMethod } from './repositories/queries/search-repository-files.js';
+export { downloadArtifactMethod } from './support/contracts/treedx/artifacts/contracts/download-artifact.js';
+export { whoamiMethod } from './support/contracts/treedx/authorization/contracts/whoami.js';
+export { parseContextDslMethod } from './support/contracts/treedx/graph/contracts/parse-context-dsl.js';
+export { deepHealthMethod } from './support/contracts/treedx/health/contracts/deep-health.js';
+export { healthMethod } from './support/contracts/treedx/health/contracts/health.js';
+export { metricsMethod } from './support/contracts/treedx/health/contracts/metrics.js';
+export { prometheusMetricsMethod } from './support/contracts/treedx/health/contracts/prometheus-metrics.js';
+export { readyMethod } from './support/contracts/treedx/health/contracts/ready.js';
+export { statusMethod } from './support/contracts/treedx/health/contracts/status.js';
+export { commitMethod } from './support/contracts/treedx/repositories/contracts/commit.js';
+export { diffMethod } from './support/contracts/treedx/repositories/contracts/diff.js';
+export { fetchRemoteMethod } from './support/contracts/treedx/repositories/contracts/fetch-remote.js';
+export { discardOrphanRefMethod, promoteRefMethod, pushMethod, retireRefMethod } from './support/contracts/treedx/repositories/contracts/push.js';
+export { compactSearchIndexMethod } from './support/contracts/treedx/search/contracts/compact-search-index.js';
+export { searchMethod } from './support/contracts/treedx/search/contracts/search.js';
+export { backupStorageMethod } from './support/contracts/treedx/storage/contracts/backup-storage.js';
+export { compactStorageMethod } from './support/contracts/treedx/storage/contracts/compact-storage.js';
+export { assertBinaryOkMethod } from './support/contracts/treedx/transport/contracts/assert-binary-ok.js';
+export { fetchWithTimeoutMethod } from './support/contracts/treedx/transport/contracts/fetch-with-timeout.js';
+export { headersMethod } from './support/contracts/treedx/transport/contracts/headers.js';
+export { parseJsonResponseMethod } from './support/contracts/treedx/transport/contracts/parse-json-response.js';
+export { queryMethod } from './support/contracts/treedx/transport/contracts/query.js';
+export { repoIdMethod } from './support/contracts/treedx/transport/contracts/repo-id.js';
+export { requestMethod } from './support/contracts/treedx/transport/contracts/request.js';
+export { throwApiErrorMethod } from './support/contracts/treedx/transport/contracts/throw-api-error.js';
+export { execMethod } from './support/contracts/treedx/workspaces/contracts/exec.js';
+export { applyStorageMigrationMethod } from './support/creation/apply-storage-migration.js';
+export { applyChangesetMethod } from './support/creation/apply-changeset.js';
+export { createMigrationMethod } from './support/creation/create-migration.js';
+export { exportArtifactMethod } from './support/creation/export-artifact.js';
+export { planStorageMigrationMethod } from './support/creation/plan-storage-migration.js';
+export { requestBinaryMethod } from './support/creation/request-binary.js';
+export { writeFileMethod } from './support/creation/write-file.js';
+export { writeFilesMethod } from './support/creation/write-files.js';
+export { getArtifactMethod } from './support/queries/treedx/artifacts/queries/get-artifact.js';
+export { listArtifactsMethod } from './support/queries/treedx/artifacts/queries/list-artifacts.js';
+export { effectiveScopeMethod } from './support/queries/treedx/authorization/queries/effective-scope.js';
+export { listCapabilitiesMethod } from './support/queries/treedx/authorization/queries/list-capabilities.js';
+export { getPlacementMethod } from './support/queries/treedx/federation/queries/get-placement.js';
+export { getNodeMethod } from './support/queries/treedx/graph/queries/get-node.js';
+export { getRelatedMethod } from './support/queries/treedx/graph/queries/get-related.js';
+export { listNodesMethod } from './support/queries/treedx/graph/queries/list-nodes.js';
+export { listTreeMethod } from './support/queries/treedx/repositories/queries/list-tree.js';
+export { readFileMethod } from './support/queries/treedx/repositories/queries/read-file.js';
+export { getSearchIndexStatusMethod } from './support/queries/treedx/search/queries/get-search-index-status.js';
+export { getMigrationMethod } from './support/queries/treedx/storage/queries/get-migration.js';
+export { getSnapshotMethod } from './support/queries/treedx/storage/queries/get-snapshot.js';
+export { listStorageMigrationsMethod } from './support/queries/treedx/storage/queries/list-storage-migrations.js';
+export { listAuditEventsMethod } from './support/queries/treedx/transport/queries/list-audit-events.js';
+export { listRepositoriesMethod } from './support/queries/treedx/transport/queries/list-repositories.js';
+export { cleanupArtifactsMethod } from './support/retirement/cleanup-artifacts.js';
+export { deleteArtifactMethod } from './support/retirement/delete-artifact.js';
+export { deleteFileMethod } from './support/retirement/delete-file.js';
+export { rollbackStorageMigrationMethod } from './support/retirement/rollback-storage-migration.js';
+export { patchFileMethod } from './support/updates/patch-file.js';
+export { refreshSearchIndexMethod } from './support/updates/refresh-search-index.js';
+export { downloadBlobMethod } from './treedx/blobs/contracts/download-blob.js';
+export { createBlobUploadMethod } from './treedx/blobs/creation/create-blob-upload.js';
+export { requestBlobDownloadMethod } from './treedx/blobs/creation/request-blob-download.js';
+export { requestBlobUploadMethod } from './treedx/blobs/creation/request-blob-upload.js';
+export { uploadBlobPartMethod } from './treedx/blobs/creation/upload-blob-part.js';
+export { uploadBlobMethod } from './treedx/blobs/creation/upload-blob.js';
+export { writeBlobMethod } from './treedx/blobs/creation/write-blob.js';
+export { completeBlobUploadMethod } from './treedx/blobs/lifecycle/complete-blob-upload.js';
+export { readBlobMethod } from './treedx/blobs/queries/read-blob.js';
+export { abortBlobUploadMethod } from './treedx/blobs/retirement/abort-blob-upload.js';
+export { deleteBlobMethod } from './treedx/blobs/retirement/delete-blob.js';
+export { federatedQueryMethod } from './treedx/federation/contracts/federated-query.js';
+export { planFederatedQueryMethod } from './treedx/federation/creation/plan-federated-query.js';
+export { checkMirrorHealthMethod } from './treedx/federation/queries/check-mirror-health.js';
+export { promoteMirrorMethod } from './treedx/federation/updates/promote-mirror.js';
+export { syncMirrorMethod } from './treedx/federation/updates/sync-mirror.js';
+export { federatedContextMethod } from './treedx/graph/contracts/federated-context.js';
+export { federatedGraphMethod } from './treedx/graph/contracts/federated-graph.js';
+export { graphSearchMethod } from './treedx/graph/contracts/graph-search.js';
+export { getGraphNodeMethod } from './treedx/graph/queries/get-graph-node.js';
+export { getGraphRefreshJobMethod } from './treedx/graph/queries/get-graph-refresh-job.js';
+export { getSubgraphMethod } from './treedx/graph/queries/get-subgraph.js';
+export { queryGraphMethod } from './treedx/graph/queries/query-graph.js';
+export { searchGraphEntitiesMethod } from './treedx/graph/queries/search-graph-entities.js';
+export { searchGraphFilesMethod } from './treedx/graph/queries/search-graph-files.js';
+export { searchGraphSectionsMethod } from './treedx/graph/queries/search-graph-sections.js';
+export { refreshGraphMethod } from './treedx/graph/updates/refresh-graph.js';
+export { federatedSearchMethod } from './treedx/search/contracts/federated-search.js';
+export { createWorkspaceMethod } from './treedx/workspaces/creation/create-workspace.js';
+export { abandonWorkspaceMethod } from './treedx/workspaces/retirement/abandon-workspace.js';
+export { closeWorkspaceMethod } from './treedx/workspaces/retirement/close-workspace.js';