@treeseed/sdk 0.12.62 → 0.13.0-rc.10

package/dist/treedx/support/client.js

@@ -0,0 +1,252 @@
+import * as extractedMethods from "../client/methods.js";
+function normalizeBaseUrl(baseUrl) {
+  return baseUrl.replace(/\/+$/u, "");
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isAbortError(error) {
+  return error instanceof DOMException && error.name === "AbortError" || error instanceof Error && error.name === "AbortError";
+}
+function stripOk(payload) {
+  if (!isRecord(payload)) {
+    return payload;
+  }
+  const { ok: _ok, ...rest } = payload;
+  return rest;
+}
+function firstPayload(payload, keys) {
+  if (isRecord(payload)) {
+    for (const key of keys) {
+      if (key in payload) {
+        return payload[key];
+      }
+    }
+  }
+  return stripOk(payload);
+}
+const TREEDX_CLIENT_OPERATION_MAP = {
+  health: "getHealth",
+  ready: "getReadiness",
+  deepHealth: "getDeepHealth",
+  adminDeepHealth: "getAdminDeepHealth",
+  metrics: "getMetrics",
+  prometheusMetrics: "getPrometheusMetrics",
+  whoami: "getWhoami",
+  authMode: "getAuthMode",
+  effectiveScope: "getEffectiveScope",
+  listCapabilities: "listCapabilities",
+  listCapabilityGrants: "listCapabilityGrants",
+  putCapabilityGrant: "putCapabilityGrant",
+  listAuditEvents: "listAuditEvents",
+  planFederatedQuery: "planFederationQuery",
+  buildSnapshot: "buildSnapshot",
+  getSnapshot: "getSnapshot",
+  exportArtifact: "exportArtifact",
+  syncMirror: "syncMirror",
+  fetchRemote: "syncRepository",
+  push: "pushRepository",
+  promoteRef: "promoteRepositoryRef",
+  retireRef: "retireRepositoryRef",
+  discardOrphanRef: "discardOrphanRepositoryRef",
+  checkMirrorHealth: "checkMirrorHealth",
+  promoteMirror: "promoteMirror",
+  compactStorage: "compactAdminStorage",
+  backupStorage: "backupAdminStorage",
+  listStorageMigrations: "listStorageMigrations",
+  planStorageMigration: "planStorageMigration",
+  applyStorageMigration: "applyStorageMigration",
+  rollbackStorageMigration: "rollbackStorageMigration",
+  verifyStorageRestore: "verifyStorageRestore",
+  restoreStorage: "restoreStorage",
+  createMigration: "createMigration",
+  getMigration: "getMigration",
+  getNode: "getLocalNode",
+  listNodes: "listRegistryNodes",
+  getPlacement: "getRepositoryPlacement",
+  getRepository: "getRepository",
+  createWorkspace: "createWorkspace",
+  closeWorkspace: "closeWorkspace",
+  listTree: "listWorkspaceTree",
+  readFile: "readWorkspaceFile",
+  writeFile: "writeWorkspaceFile",
+  patchFile: "patchWorkspaceFile",
+  deleteFile: "deleteWorkspaceFile",
+  readBlob: "readRepositoryBlob",
+  writeBlob: "writeWorkspaceBlob",
+  deleteBlob: "deleteWorkspaceBlob",
+  downloadBlob: "downloadWorkspaceBlob",
+  uploadBlob: "uploadWorkspaceBlob",
+  createBlobUpload: "createWorkspaceBlobUpload",
+  uploadBlobPart: "uploadWorkspaceBlobPart",
+  completeBlobUpload: "completeWorkspaceBlobUpload",
+  abortBlobUpload: "abortWorkspaceBlobUpload",
+  listArtifacts: "listArtifacts",
+  getArtifact: "getArtifact",
+  deleteArtifact: "deleteArtifact",
+  cleanupArtifacts: "cleanupArtifacts",
+  search: "searchWorkspace",
+  status: "getWorkspaceStatus",
+  diff: "getWorkspaceDiff",
+  commit: "commitWorkspace",
+  exec: "execWorkspace",
+  readRepositoryFiles: "readRepositoryFile",
+  readRepositoryFile: "readRepositoryFile",
+  listRepositoryPaths: "listRepositoryPaths",
+  searchRepositoryFiles: "searchRepositoryFiles",
+  queryRepository: "queryRepository",
+  federatedSearch: "federatedSearch",
+  federatedQuery: "federatedQuery",
+  federatedContext: "federatedContextBuild",
+  federatedGraph: "federatedGraphQuery",
+  refreshGraph: "refreshRepositoryGraph",
+  getGraphRefreshJob: "getGraphRefreshJob",
+  refreshSearchIndex: "refreshSearchIndex",
+  getSearchIndexStatus: "getSearchIndexStatus",
+  compactSearchIndex: "compactSearchIndex",
+  queryGraph: "queryRepositoryGraph",
+  searchGraphFiles: "searchGraphFiles",
+  searchGraphSections: "searchGraphSections",
+  searchGraphEntities: "searchGraphEntities",
+  getGraphNode: "getGraphNode",
+  getRelated: "getRelatedGraphNodes",
+  getSubgraph: "getGraphSubgraph",
+  buildContext: "buildContext",
+  parseContextDsl: "parseContextQuery"
+};
+class TreeDxClient {
+  constructor(options) {
+    this.options = options;
+    this.baseUrl = normalizeBaseUrl(options.baseUrl);
+    this.token = options.token;
+    this.defaultRepoId = options.repoId;
+    this.fetchImpl = options.fetch ?? fetch;
+  }
+  options;
+  baseUrl;
+  token;
+  defaultRepoId;
+  fetchImpl;
+}
+TreeDxClient.prototype.repoId = extractedMethods.repoIdMethod;
+TreeDxClient.prototype.query = extractedMethods.queryMethod;
+TreeDxClient.prototype.headers = extractedMethods.headersMethod;
+TreeDxClient.prototype.fetchWithTimeout = extractedMethods.fetchWithTimeoutMethod;
+TreeDxClient.prototype.request = extractedMethods.requestMethod;
+TreeDxClient.prototype.requestBinary = extractedMethods.requestBinaryMethod;
+TreeDxClient.prototype.requestBlobDownload = extractedMethods.requestBlobDownloadMethod;
+TreeDxClient.prototype.requestBlobUpload = extractedMethods.requestBlobUploadMethod;
+TreeDxClient.prototype.assertBinaryOk = extractedMethods.assertBinaryOkMethod;
+TreeDxClient.prototype.parseJsonResponse = extractedMethods.parseJsonResponseMethod;
+TreeDxClient.prototype.throwApiError = extractedMethods.throwApiErrorMethod;
+TreeDxClient.prototype.health = extractedMethods.healthMethod;
+TreeDxClient.prototype.ready = extractedMethods.readyMethod;
+TreeDxClient.prototype.deepHealth = extractedMethods.deepHealthMethod;
+TreeDxClient.prototype.metrics = extractedMethods.metricsMethod;
+TreeDxClient.prototype.prometheusMetrics = extractedMethods.prometheusMetricsMethod;
+TreeDxClient.prototype.whoami = extractedMethods.whoamiMethod;
+TreeDxClient.prototype.authMode = extractedMethods.authModeMethod;
+TreeDxClient.prototype.effectiveScope = extractedMethods.effectiveScopeMethod;
+TreeDxClient.prototype.listCapabilities = extractedMethods.listCapabilitiesMethod;
+TreeDxClient.prototype.listCapabilityGrants = extractedMethods.listCapabilityGrantsMethod;
+TreeDxClient.prototype.putCapabilityGrant = extractedMethods.putCapabilityGrantMethod;
+TreeDxClient.prototype.listAuditEvents = extractedMethods.listAuditEventsMethod;
+TreeDxClient.prototype.planFederatedQuery = extractedMethods.planFederatedQueryMethod;
+TreeDxClient.prototype.buildSnapshot = extractedMethods.buildSnapshotMethod;
+TreeDxClient.prototype.getSnapshot = extractedMethods.getSnapshotMethod;
+TreeDxClient.prototype.exportArtifact = extractedMethods.exportArtifactMethod;
+TreeDxClient.prototype.downloadArtifact = extractedMethods.downloadArtifactMethod;
+TreeDxClient.prototype.syncMirror = extractedMethods.syncMirrorMethod;
+TreeDxClient.prototype.fetchRemote = extractedMethods.fetchRemoteMethod;
+TreeDxClient.prototype.push = extractedMethods.pushMethod;
+TreeDxClient.prototype.promoteRef = extractedMethods.promoteRefMethod;
+TreeDxClient.prototype.retireRef = extractedMethods.retireRefMethod;
+TreeDxClient.prototype.discardOrphanRef = extractedMethods.discardOrphanRefMethod;
+TreeDxClient.prototype.listRepositoryRefs = extractedMethods.listRepositoryRefsMethod;
+TreeDxClient.prototype.abandonWorkspace = extractedMethods.abandonWorkspaceMethod;
+TreeDxClient.prototype.checkMirrorHealth = extractedMethods.checkMirrorHealthMethod;
+TreeDxClient.prototype.promoteMirror = extractedMethods.promoteMirrorMethod;
+TreeDxClient.prototype.compactStorage = extractedMethods.compactStorageMethod;
+TreeDxClient.prototype.backupStorage = extractedMethods.backupStorageMethod;
+TreeDxClient.prototype.listStorageMigrations = extractedMethods.listStorageMigrationsMethod;
+TreeDxClient.prototype.planStorageMigration = extractedMethods.planStorageMigrationMethod;
+TreeDxClient.prototype.applyStorageMigration = extractedMethods.applyStorageMigrationMethod;
+TreeDxClient.prototype.rollbackStorageMigration = extractedMethods.rollbackStorageMigrationMethod;
+TreeDxClient.prototype.verifyStorageRestore = extractedMethods.verifyStorageRestoreMethod;
+TreeDxClient.prototype.restoreStorage = extractedMethods.restoreStorageMethod;
+TreeDxClient.prototype.createMigration = extractedMethods.createMigrationMethod;
+TreeDxClient.prototype.getMigration = extractedMethods.getMigrationMethod;
+TreeDxClient.prototype.getNode = extractedMethods.getNodeMethod;
+TreeDxClient.prototype.listNodes = extractedMethods.listNodesMethod;
+TreeDxClient.prototype.getPlacement = extractedMethods.getPlacementMethod;
+TreeDxClient.prototype.getRepository = extractedMethods.getRepositoryMethod;
+TreeDxClient.prototype.listRepositories = extractedMethods.listRepositoriesMethod;
+TreeDxClient.prototype.registerRepository = extractedMethods.registerRepositoryMethod;
+TreeDxClient.prototype.createWorkspace = extractedMethods.createWorkspaceMethod;
+TreeDxClient.prototype.closeWorkspace = extractedMethods.closeWorkspaceMethod;
+TreeDxClient.prototype.listTree = extractedMethods.listTreeMethod;
+TreeDxClient.prototype.readFile = extractedMethods.readFileMethod;
+TreeDxClient.prototype.writeFile = extractedMethods.writeFileMethod;
+TreeDxClient.prototype.writeFiles = extractedMethods.writeFilesMethod;
+TreeDxClient.prototype.applyChangeset = extractedMethods.applyChangesetMethod;
+TreeDxClient.prototype.patchFile = extractedMethods.patchFileMethod;
+TreeDxClient.prototype.deleteFile = extractedMethods.deleteFileMethod;
+TreeDxClient.prototype.readBlob = extractedMethods.readBlobMethod;
+TreeDxClient.prototype.writeBlob = extractedMethods.writeBlobMethod;
+TreeDxClient.prototype.deleteBlob = extractedMethods.deleteBlobMethod;
+TreeDxClient.prototype.downloadBlob = extractedMethods.downloadBlobMethod;
+TreeDxClient.prototype.uploadBlob = extractedMethods.uploadBlobMethod;
+TreeDxClient.prototype.createBlobUpload = extractedMethods.createBlobUploadMethod;
+TreeDxClient.prototype.uploadBlobPart = extractedMethods.uploadBlobPartMethod;
+TreeDxClient.prototype.completeBlobUpload = extractedMethods.completeBlobUploadMethod;
+TreeDxClient.prototype.abortBlobUpload = extractedMethods.abortBlobUploadMethod;
+TreeDxClient.prototype.listArtifacts = extractedMethods.listArtifactsMethod;
+TreeDxClient.prototype.getArtifact = extractedMethods.getArtifactMethod;
+TreeDxClient.prototype.deleteArtifact = extractedMethods.deleteArtifactMethod;
+TreeDxClient.prototype.cleanupArtifacts = extractedMethods.cleanupArtifactsMethod;
+TreeDxClient.prototype.search = extractedMethods.searchMethod;
+TreeDxClient.prototype.status = extractedMethods.statusMethod;
+TreeDxClient.prototype.diff = extractedMethods.diffMethod;
+TreeDxClient.prototype.commit = extractedMethods.commitMethod;
+TreeDxClient.prototype.exec = extractedMethods.execMethod;
+TreeDxClient.prototype.readRepositoryFiles = extractedMethods.readRepositoryFilesMethod;
+TreeDxClient.prototype.readRepositoryFile = extractedMethods.readRepositoryFileMethod;
+TreeDxClient.prototype.listRepositoryPaths = extractedMethods.listRepositoryPathsMethod;
+TreeDxClient.prototype.searchRepositoryFiles = extractedMethods.searchRepositoryFilesMethod;
+TreeDxClient.prototype.queryRepository = extractedMethods.queryRepositoryMethod;
+TreeDxClient.prototype.federatedSearch = extractedMethods.federatedSearchMethod;
+TreeDxClient.prototype.federatedQuery = extractedMethods.federatedQueryMethod;
+TreeDxClient.prototype.federatedContext = extractedMethods.federatedContextMethod;
+TreeDxClient.prototype.federatedGraph = extractedMethods.federatedGraphMethod;
+TreeDxClient.prototype.refreshGraph = extractedMethods.refreshGraphMethod;
+TreeDxClient.prototype.getGraphRefreshJob = extractedMethods.getGraphRefreshJobMethod;
+TreeDxClient.prototype.refreshSearchIndex = extractedMethods.refreshSearchIndexMethod;
+TreeDxClient.prototype.getSearchIndexStatus = extractedMethods.getSearchIndexStatusMethod;
+TreeDxClient.prototype.compactSearchIndex = extractedMethods.compactSearchIndexMethod;
+TreeDxClient.prototype.queryGraph = extractedMethods.queryGraphMethod;
+TreeDxClient.prototype.searchGraphFiles = extractedMethods.searchGraphFilesMethod;
+TreeDxClient.prototype.searchGraphSections = extractedMethods.searchGraphSectionsMethod;
+TreeDxClient.prototype.searchGraphEntities = extractedMethods.searchGraphEntitiesMethod;
+TreeDxClient.prototype.getGraphNode = extractedMethods.getGraphNodeMethod;
+TreeDxClient.prototype.getRelated = extractedMethods.getRelatedMethod;
+TreeDxClient.prototype.getSubgraph = extractedMethods.getSubgraphMethod;
+TreeDxClient.prototype.buildContext = extractedMethods.buildContextMethod;
+TreeDxClient.prototype.parseContextDsl = extractedMethods.parseContextDslMethod;
+TreeDxClient.prototype.graphSearch = extractedMethods.graphSearchMethod;
+function parseFilename(contentDisposition) {
+  if (!contentDisposition) {
+    return void 0;
+  }
+  const match = /filename="([^"]+)"/u.exec(contentDisposition) ?? /filename=([^;]+)/u.exec(contentDisposition);
+  return match?.[1];
+}
+export {
+  TREEDX_CLIENT_OPERATION_MAP,
+  TreeDxClient,
+  firstPayload,
+  isAbortError,
+  isRecord,
+  normalizeBaseUrl,
+  parseFilename,
+  stripOk
+};

package/dist/treedx/support/errors.d.ts

@@ -0,0 +1,13 @@
+import type { TreeDxErrorCode } from '../types.js';
+export declare class TreeDxApiError extends Error {
+    readonly status: number;
+    readonly code: TreeDxErrorCode;
+    readonly details: Record<string, unknown>;
+    readonly payload: unknown;
+    constructor(message: string, options: {
+        status: number;
+        code?: TreeDxErrorCode;
+        details?: Record<string, unknown>;
+        payload?: unknown;
+    });
+}

package/dist/treedx/types/tree-dx-actor.d.ts

@@ -0,0 +1,209 @@
+import type { components } from '../generated/openapi-types.js';
+export interface TreeDxActor {
+    actorId: string;
+    tenantId: string;
+}
+export interface TreeDxClientOptions {
+    baseUrl: string;
+    token?: string;
+    repoId?: string;
+    fetch?: typeof fetch;
+    defaultRef?: string;
+    defaultActor?: TreeDxActor;
+    timeoutMs?: number;
+}
+export type TreeDxErrorCode = components['schemas']['TreeDxErrorCode'] | 'missing_repo_id' | 'missing_token' | 'invalid_response' | 'treedx_api_error' | 'model_not_content_backed' | 'operation_not_allowed' | 'missing_content_path_mapping' | 'not_implemented' | 'workspace_required' | 'node_not_configured' | 'unsupported_treedx_graph_operation' | (string & {});
+export interface TreeDxOkEnvelope<T> {
+    ok: true;
+    [key: string]: unknown;
+}
+export interface TreeDxErrorBody {
+    code: string;
+    message: string;
+    details?: Record<string, unknown>;
+}
+export interface TreeDxErrorEnvelope {
+    ok: false;
+    error: TreeDxErrorBody;
+}
+export declare function assertTreeDxOk<T extends Record<string, unknown>>(value: unknown, label?: string): asserts value is T & {
+    ok: true;
+};
+export interface TreeDxHealth {
+    status: string;
+    service: string;
+    dataDir?: string;
+}
+export type TreeDxReadiness = components['schemas']['TreeDxReadiness'];
+export type TreeDxDeepHealth = components['schemas']['TreeDxHealthSummary'];
+export type TreeDxMetrics = components['schemas']['TreeDxMetrics'];
+export interface TreeDxVersion {
+    service: string;
+    version: string;
+    apiVersion: string;
+}
+export interface TreeDxPrincipal {
+    actorId: string;
+    tenantId: string;
+    authMode?: string;
+}
+export interface TreeDxWhoami {
+    authenticated: boolean;
+    principal: TreeDxPrincipal | null;
+}
+export interface TreeDxEffectiveScopeRequest {
+    repoId?: string;
+}
+export interface TreeDxEffectiveScope {
+    actorId: string;
+    tenantIds: string[];
+    repoId?: string | null;
+    capabilities: string[];
+    refs: string[];
+    paths: string[];
+    policyVersion?: string;
+    policyHash?: string;
+}
+export interface TreeDxAuthMode {
+    mode: 'dev' | 'connected';
+    connected: boolean;
+    verifier?: {
+        type: 'jwt_hs256' | 'hs256_dev' | 'jwks_oidc' | 'trusted_internal';
+        issuer?: string;
+        jwksUrl?: string;
+    };
+}
+export interface TreeDxCapabilityGrant {
+    id?: string;
+    actorId: string;
+    tenantId: string;
+    repoIds: string[];
+    capabilities: string[];
+    refs: string[];
+    paths: string[];
+    expiresAt?: string | null;
+    revokedAt?: string | null;
+    revokedByActorId?: string | null;
+    revocationReason?: string | null;
+}
+export interface TreeDxAuditEvent {
+    id: string;
+    eventType: string;
+    actorId?: string | null;
+    tenantId?: string | null;
+    repoId?: string | null;
+    nodeId?: string | null;
+    workspaceId?: string | null;
+    operation?: string | null;
+    status?: string | null;
+    requestId?: string | null;
+    requestedScope?: Record<string, unknown> | null;
+    effectiveScope?: Record<string, unknown> | null;
+    data: Record<string, unknown>;
+    recordedAt: string;
+}
+export interface TreeDxFederationQueryPlanRequest {
+    repoIds: string[];
+    refs?: Record<string, string>;
+    paths?: Record<string, string[]>;
+    queryType?: string;
+    capabilities?: string[];
+}
+export interface TreeDxFederationQueryPlan {
+    requestedScope: Record<string, unknown>;
+    effectiveScope: Record<string, unknown>;
+    rejected: Array<Record<string, unknown>>;
+    executable: false;
+    reason: string;
+}
+export interface TreeDxNode {
+    id: string;
+    baseUrl: string;
+    role: string;
+    health: string;
+}
+export interface TreeDxRepositoryPlacement {
+    repositoryId?: string;
+    repoId?: string;
+    primaryNodeId: string;
+    mirrorNodeIds: string[];
+    readPolicy: string;
+    writePolicy: string;
+    migrationState: string;
+}
+export interface TreeDxMirror {
+    id?: string;
+    repositoryId?: string;
+    repoId?: string;
+    sourceNodeId: string;
+    targetNodeId: string;
+    mode: string;
+    lastSeenCommit?: string | null;
+    behindBy?: number | null;
+    status: string;
+}
+export interface TreeDxRepository {
+    repoId: string;
+    name: string;
+    repositoryName?: string;
+    defaultRef: string;
+    status: string;
+    remoteUrl?: string | null;
+}
+export interface TreeDxRegisterRepositoryRequest {
+    name: string;
+    repositoryName?: string;
+    createIfMissing?: boolean;
+    defaultRef?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface TreeDxRef {
+    name: string;
+    target?: string | null;
+    sha?: string | null;
+    kind: string;
+}
+export interface TreeDxWorkspaceAbandonResult {
+    workspace: TreeDxWorkspace;
+    discardedRef: {
+        ref: string;
+        head: string;
+        status: 'discarded' | 'already_discarded';
+    };
+}
+export interface TreeDxRemote {
+    name: string;
+    url?: string | null;
+}
+export interface TreeDxRepositoryStatus {
+    repo: TreeDxRepository;
+    git: Record<string, unknown>;
+    placement?: TreeDxRepositoryPlacement | null;
+}
+export interface TreeDxCreateWorkspaceRequest {
+    workspaceId?: string;
+    repoId?: string;
+    baseRef?: string;
+    branchName?: string;
+    mode?: 'writable' | 'read_only';
+    allowedPaths?: string[];
+    ttlSeconds?: number;
+}
+export interface TreeDxWorkspace {
+    workspaceId: string;
+    repoId: string;
+    baseRef: string;
+    baseCommitSha: string;
+    branchName?: string | null;
+    mode: 'writable' | 'read_only';
+    status: string;
+    allowedPaths: string[];
+    commitSha?: string | null;
+    policyVersion?: string;
+    policyHash?: string;
+    revokedAt?: string | null;
+    revokedReason?: string | null;
+}
+export interface TreeDxWorkspaceRequest {
+    workspaceId: string;
+}

package/dist/treedx/types/tree-dx-actor.js

@@ -0,0 +1,8 @@
+function assertTreeDxOk(value, label = "TreeDX response") {
+  if (typeof value !== "object" || value === null || Array.isArray(value) || value.ok !== true) {
+    throw new Error(`${label} was not an ok TreeDX response.`);
+  }
+}
+export {
+  assertTreeDxOk
+};

package/dist/treedx/types/tree-dx-artifact-list-response.d.ts

@@ -0,0 +1,13 @@
+import type { components } from '../generated/openapi-types.js';
+export type TreeDxArtifactListResponse = components['schemas']['TreeDxListArtifactsResponse'];
+export type TreeDxMirrorListResponse = components['schemas']['TreeDxListMirrorsResponse'];
+export type TreeDxMirrorResponse = components['schemas']['TreeDxPutMirrorResponse'];
+export type TreeDxMigrationResponse = components['schemas']['TreeDxGetMigrationResponse'];
+export type TreeDxFederationQueryPlanResponse = components['schemas']['TreeDxPlanFederationQueryResponse'];
+export type TreeDxFederatedSearchResponse = components['schemas']['TreeDxFederatedSearchResponse'];
+export type TreeDxFederatedQueryResponse = components['schemas']['TreeDxFederatedQueryResponse'];
+export type TreeDxFederatedContextResponse = components['schemas']['TreeDxFederatedContextBuildResponse'];
+export type TreeDxFederatedGraphResponse = components['schemas']['TreeDxFederatedGraphQueryResponse'];
+export type TreeDxStorageHealthResponse = components['schemas']['TreeDxGetAdminStorageHealthResponse'];
+export type TreeDxStorageCheckResponse = components['schemas']['TreeDxCheckAdminStorageResponse'];
+export type TreeDxStorageMigrationListResponse = components['schemas']['TreeDxListStorageMigrationsResponse'];

package/dist/treedx/types/tree-dx-changeset.d.ts

@@ -0,0 +1,51 @@
+import type { TreeDxWorkspaceRequest } from './tree-dx-actor.js';
+export declare const TREE_DX_CHANGESET_CONTRACT: "treedx.changeset/v1";
+export declare const ARTIFACT_REF_CONTRACT: "treeseed.artifact-ref/v1";
+export interface ArtifactRef {
+    contract: typeof ARTIFACT_REF_CONTRACT;
+    kind: 'treedx-content' | 'repository-file' | 'r2-object' | 'verification-evidence' | 'provider-input' | 'provider-output' | 'citation' | 'source-commit';
+    repositoryId?: string;
+    workspaceId?: string;
+    path?: string;
+    commitSha?: string | null;
+    objectKey?: string;
+    sha256: string | null;
+    byteLength?: number;
+    mediaType?: string;
+    visibility: 'private' | 'assignment' | 'project' | 'team' | 'public';
+    assignmentId?: string;
+    toolCallId?: string;
+    eventId?: string;
+    provenance?: Record<string, string>;
+}
+export interface TreeDxChangesetRequest extends TreeDxWorkspaceRequest {
+    contract: typeof TREE_DX_CHANGESET_CONTRACT;
+    baseCommitSha: string;
+    baseRef: string;
+    patch: string;
+    patchSha256: string;
+    idempotencyKey: string;
+    expectedWorkspaceVersion?: string;
+    expectedDestinationRefHead?: string;
+}
+export interface TreeDxChangesetFileReceipt {
+    path: string;
+    beforeSha256: string | null;
+    afterSha256: string | null;
+    byteLength: number;
+}
+export interface TreeDxChangesetReceipt {
+    contract: typeof TREE_DX_CHANGESET_CONTRACT;
+    repositoryId: string;
+    workspaceId: string;
+    baseRef: string;
+    baseCommitSha: string;
+    resultCommitSha: string | null;
+    branch: string;
+    changedPaths: string[];
+    files: TreeDxChangesetFileReceipt[];
+    patchSha256: string;
+    idempotencyKey: string;
+    idempotentReplay: boolean;
+    workspaceVersion: string;
+}

package/dist/treedx/types/tree-dx-changeset.js

@@ -0,0 +1,6 @@
+const TREE_DX_CHANGESET_CONTRACT = "treedx.changeset/v1";
+const ARTIFACT_REF_CONTRACT = "treeseed.artifact-ref/v1";
+export {
+  ARTIFACT_REF_CONTRACT,
+  TREE_DX_CHANGESET_CONTRACT
+};