@treeseed/sdk 0.6.33 → 0.6.34

package/dist/operations/services/deploy.d.ts

@@ -998,6 +998,7 @@ export declare function runRemoteD1Migrations(tenantRoot: any, options?: {}): {
 };
 export declare function markDeploymentInitialized(tenantRoot: any, options?: {}): any;
 export declare function markManagedServicesInitialized(tenantRoot: any, options?: {}): any;
+export declare function recordHostedDeploymentState(tenantRoot: any, options?: {}): any;
 export declare function assertDeploymentInitialized(tenantRoot: any, options?: {}): any;
 export declare function finalizeDeploymentState(tenantRoot: any, options?: {}): any;
 export declare function printDeploySummary(summary: any): void;

package/dist/operations/services/deploy.js

@@ -2096,6 +2096,42 @@ function markManagedServicesInitialized(tenantRoot, options = {}) {
   writeDeployState(tenantRoot, state, { target });
   return state;
 }
+function recordHostedDeploymentState(tenantRoot, options = {}) {
+  const target = normalizeTarget(options.scope ?? options.target ?? "prod");
+  const deployConfig = loadTenantDeployConfig(tenantRoot);
+  const state = loadDeployState(tenantRoot, deployConfig, { target });
+  const timestamp = typeof options.timestamp === "string" && options.timestamp.trim() ? options.timestamp.trim() : (/* @__PURE__ */ new Date()).toISOString();
+  const deployedUrl = typeof options.url === "string" && options.url.trim() ? options.url.trim() : state.lastDeployedUrl ?? resolveConfiguredSurfaceBaseUrl(deployConfig, target, "web");
+  const commit = typeof options.commit === "string" && options.commit.trim() ? options.commit.trim() : null;
+  state.lastDeployedUrl = deployedUrl;
+  state.lastDeploymentTimestamp = timestamp;
+  state.lastDeployedCommit = commit;
+  state.readiness = {
+    ...state.readiness ?? {},
+    initialized: true,
+    configured: true,
+    provisioned: true,
+    deployable: true,
+    phase: "provisioned",
+    initializedAt: state.readiness?.initializedAt ?? timestamp,
+    lastValidatedAt: timestamp,
+    blockers: [],
+    warnings: state.readiness?.warnings ?? []
+  };
+  const nextHistoryEntry = {
+    commit,
+    timestamp,
+    url: deployedUrl,
+    target: deployTargetLabel(target),
+    source: options.source ?? "hosted-github-workflow",
+    workflow: options.workflow ?? null,
+    runId: options.runId ?? null
+  };
+  const history = Array.isArray(state.deploymentHistory) ? state.deploymentHistory : [];
+  state.deploymentHistory = [...history, nextHistoryEntry].slice(-20);
+  writeDeployState(tenantRoot, state, { target });
+  return state;
+}
 function assertDeploymentInitialized(tenantRoot, options = {}) {
   const target = normalizeTarget(options.scope ?? options.target ?? "prod");
   const deployConfig = loadTenantDeployConfig(tenantRoot);
@@ -2225,6 +2261,7 @@ export {
   queueId,
   queueName,
   reconcileCloudflareWebCacheRules,
+  recordHostedDeploymentState,
   resolveCloudflareZoneIdForHost,
   resolveConfiguredCloudflareAccountId,
   resolveConfiguredSurfaceBaseUrl,

package/dist/operations/services/git-workflow.d.ts

@@ -119,15 +119,32 @@ export declare function mergeCurrentBranchIntoStaging(cwd: any, featureBranch: a
     committed: boolean;
     commitSha: string;
     pushed: boolean;
+    generatedMetadataReconciliation: {
+        commitSha: null;
+        resolved: boolean;
+        repoDir: any;
+        targetBranch: string;
+        reconciledFiles: string[];
+        allConflictsWereGeneratedMetadata: boolean;
+    } | null;
 };
-export declare function squashMergeBranchIntoStaging(cwd: any, featureBranch: any, message: any, { pushTarget }?: {
+export declare function squashMergeBranchIntoStaging(cwd: any, featureBranch: any, message: any, { pushTarget, reportGeneratedMetadataReconciliation }?: {
     pushTarget?: boolean | undefined;
+    reportGeneratedMetadataReconciliation?: boolean | undefined;
 }): {
     repoDir: string;
     targetBranch: string;
     committed: boolean;
     commitSha: string;
     pushed: boolean;
+    generatedMetadataReconciliation: {
+        commitSha: null;
+        resolved: boolean;
+        repoDir: any;
+        targetBranch: string;
+        reconciledFiles: string[];
+        allConflictsWereGeneratedMetadata: boolean;
+    } | null;
 };
 export declare function currentManagedBranch(cwd?: any): string;
 export declare function isTaskBranch(branchName: any): boolean;

package/dist/operations/services/git-workflow.js

@@ -28,14 +28,34 @@ function conflictedFiles(repoDir) {
 }
 function resolveGeneratedPackageMetadataConflicts(repoDir) {
   const files = conflictedFiles(repoDir);
-  if (files.length === 0) return false;
+  if (files.length === 0) {
+    return {
+      resolved: false,
+      repoDir,
+      targetBranch: STAGING_BRANCH,
+      reconciledFiles: [],
+      allConflictsWereGeneratedMetadata: false
+    };
+  }
   const generatedMetadataFiles = /* @__PURE__ */ new Set(["package.json", "package-lock.json"]);
   if (files.some((file) => !generatedMetadataFiles.has(file))) {
-    return false;
+    return {
+      resolved: false,
+      repoDir,
+      targetBranch: STAGING_BRANCH,
+      reconciledFiles: files,
+      allConflictsWereGeneratedMetadata: false
+    };
   }
   runGit(["checkout", "--theirs", "--", ...files], { cwd: repoDir });
   runGit(["add", "--", ...files], { cwd: repoDir });
-  return true;
+  return {
+    resolved: true,
+    repoDir,
+    targetBranch: STAGING_BRANCH,
+    reconciledFiles: files,
+    allConflictsWereGeneratedMetadata: true
+  };
 }
 function headCommit(repoDir, ref = "HEAD") {
   return runGit(["rev-parse", ref], { cwd: repoDir, capture: true }).trim();
@@ -301,22 +321,35 @@ function deleteRemoteBranch(repoDir, branchName) {
 function mergeCurrentBranchIntoStaging(cwd, featureBranch) {
   return squashMergeBranchIntoStaging(cwd, featureBranch, `stage: ${featureBranch}`);
 }
-function squashMergeBranchIntoStaging(cwd, featureBranch, message, { pushTarget = true } = {}) {
+function squashMergeBranchIntoStaging(cwd, featureBranch, message, { pushTarget = true, reportGeneratedMetadataReconciliation = true } = {}) {
   const repoDir = assertCleanWorktree(cwd);
   fetchOrigin(repoDir);
   syncBranchWithOrigin(repoDir, STAGING_BRANCH);
+  let generatedMetadataReconciliation = null;
   try {
-    runGit(["merge", "--squash", featureBranch], { cwd: repoDir });
+    runGit(["merge", "--squash", featureBranch], { cwd: repoDir, capture: true });
   } catch (error) {
-    if (!resolveGeneratedPackageMetadataConflicts(repoDir)) {
+    const reconciliation = resolveGeneratedPackageMetadataConflicts(repoDir);
+    if (!reconciliation.resolved) {
       throw error;
     }
+    if (reportGeneratedMetadataReconciliation) {
+      console.log(`Resolving generated package metadata reconciliation for ${reconciliation.reconciledFiles.join(", ")}.`);
+    }
+    generatedMetadataReconciliation = {
+      ...reconciliation,
+      commitSha: null
+    };
   }
   let committed = false;
   if (repoHasStagedChanges(repoDir)) {
     runGit(["commit", "-m", message], { cwd: repoDir });
     committed = true;
   }
+  const commitSha = headCommit(repoDir);
+  if (generatedMetadataReconciliation) {
+    generatedMetadataReconciliation.commitSha = commitSha;
+  }
   if (pushTarget) {
     pushBranch(repoDir, STAGING_BRANCH);
   }
@@ -324,8 +357,9 @@ function squashMergeBranchIntoStaging(cwd, featureBranch, message, { pushTarget
     repoDir,
     targetBranch: STAGING_BRANCH,
     committed,
-    commitSha: headCommit(repoDir),
-    pushed: pushTarget
+    commitSha,
+    pushed: pushTarget,
+    generatedMetadataReconciliation
   };
 }
 function currentManagedBranch(cwd = workspaceRoot()) {

package/dist/operations/services/github-actions-verification.d.ts

@@ -114,6 +114,8 @@ export declare function skippedGitHubActionsGate(gate: GitHubActionsWorkflowGate
     conclusion: null;
     runId: null;
     url: null;
+    createdAt: null;
+    updatedAt: null;
 };
 export declare function formatGitHubActionsGateFailure(gate: GitHubActionsWorkflowGate, result: Record<string, unknown>): string;
 export declare function waitForGitHubActionsGate(gate: GitHubActionsWorkflowGate, options?: {

package/dist/operations/services/github-actions-verification.js

@@ -406,7 +406,9 @@ function skippedGitHubActionsGate(gate, reason) {
     reason,
     conclusion: null,
     runId: null,
-    url: null
+    url: null,
+    createdAt: null,
+    updatedAt: null
   };
 }
 function formatGitHubActionsGateFailure(gate, result) {

package/dist/operations/services/github-api.d.ts

@@ -26,6 +26,8 @@ export interface GitHubWorkflowRunSummary {
     url: string | null;
     headSha: string | null;
     headBranch: string | null;
+    createdAt: string | null;
+    updatedAt: string | null;
 }
 export interface GitHubWorkflowJobSummary {
     id: number;
@@ -162,6 +164,8 @@ export declare function waitForGitHubWorkflowRunCompletion(repository: string |
     runId: number;
     headSha: string | null;
     branch: string | null;
+    createdAt: string | null;
+    updatedAt: string | null;
     conclusion: string | null;
     url: string | null;
     jobs: GitHubWorkflowJobSummary[];

package/dist/operations/services/github-api.js

@@ -520,7 +520,9 @@ function normalizeWorkflowRun(run) {
     conclusion: typeof run.conclusion === "string" ? run.conclusion : null,
     url: typeof run.html_url === "string" ? run.html_url : null,
     headSha: typeof run.head_sha === "string" ? run.head_sha : null,
-    headBranch: typeof run.head_branch === "string" ? run.head_branch : null
+    headBranch: typeof run.head_branch === "string" ? run.head_branch : null,
+    createdAt: typeof run.created_at === "string" ? run.created_at : null,
+    updatedAt: typeof run.updated_at === "string" ? run.updated_at : null
   };
 }
 function normalizeWorkflowJob(job) {
@@ -623,6 +625,8 @@ async function waitForGitHubWorkflowRunCompletion(repository, {
             runId: normalized.id,
             headSha: normalized.headSha,
             branch: normalized.headBranch,
+            createdAt: normalized.createdAt,
+            updatedAt: normalized.updatedAt,
             conclusion: normalized.conclusion,
             url: normalized.url,
             jobs: normalizedJobs,

package/dist/operations/services/github-automation.d.ts

@@ -284,6 +284,8 @@ export declare function waitForGitHubWorkflowCompletion(tenantRoot: any, { repos
     runId: number;
     headSha: string | null;
     branch: string | null;
+    createdAt: string | null;
+    updatedAt: string | null;
     conclusion: string | null;
     url: string | null;
     jobs: import("./github-api.ts").GitHubWorkflowJobSummary[];

package/dist/scripts/check-build-warnings.js

@@ -5,7 +5,10 @@ import { resolve } from 'node:path';
 
 const args = process.argv.slice(2);
 const defaultAllowlisted = [
-	/Module "url" has been externalized for browser compatibility, imported by ".*libsodium-sumo.*"/u,
+	{
+		label: 'vite-browser-external-libsodium-url',
+		pattern: /Module "url" has been externalized for browser compatibility, imported by ".*libsodium-sumo.*"/u,
+	},
 ];
 const allowlisted = [];
 const files = [];
@@ -22,7 +25,10 @@ for (let index = 0; index < args.length; index += 1) {
 		if (!pattern) {
 			throw new Error('Missing value for --allow.');
 		}
-		allowlisted.push(new RegExp(pattern));
+		allowlisted.push({
+			label: `custom:${pattern}`,
+			pattern: new RegExp(pattern),
+		});
 		index += 1;
 		continue;
 	}
@@ -34,6 +40,7 @@ if (files.length === 0) {
 }
 
 const warningLines = [];
+const allowedWarnings = new Map();
 const effectiveAllowlisted = [
 	...(useDefaultPolicy ? defaultAllowlisted : []),
 	...allowlisted,
@@ -44,7 +51,10 @@ for (const file of files) {
 		if (!line.includes('[WARN]')) {
 			continue;
 		}
-		if (effectiveAllowlisted.some((pattern) => pattern.test(line))) {
+		const allowed = effectiveAllowlisted.find((rule) => rule.pattern.test(line));
+		if (allowed) {
+			const current = allowedWarnings.get(allowed.label) ?? 0;
+			allowedWarnings.set(allowed.label, current + 1);
 			continue;
 		}
 		warningLines.push(line);
@@ -59,4 +69,11 @@ if (warningLines.length > 0) {
 	process.exit(1);
 }
 
+const allowedTotal = [...allowedWarnings.values()].reduce((sum, count) => sum + count, 0);
+if (allowedTotal > 0) {
+	console.log(`Allowed build warnings: ${allowedTotal}`);
+	for (const [label, count] of [...allowedWarnings.entries()].sort(([left], [right]) => left.localeCompare(right))) {
+		console.log(`- ${label}: ${count}`);
+	}
+}
 console.log('No unexpected build warnings detected.');

package/dist/workflow/operations.d.ts

@@ -415,6 +415,8 @@ export declare function workflowSave(helpers: WorkflowOperationHelpers, input: T
         conclusion: null;
         runId: null;
         url: null;
+        createdAt: null;
+        updatedAt: null;
     }[];
     releaseCandidate: ReleaseCandidateReport | null;
 } & {
@@ -553,6 +555,8 @@ export declare function workflowClose(helpers: WorkflowOperationHelpers, input:
             conclusion: null;
             runId: null;
             url: null;
+            createdAt: null;
+            updatedAt: null;
         }[];
         releaseCandidate: ReleaseCandidateReport | null;
     } & {
@@ -732,6 +736,8 @@ export declare function workflowStage(helpers: WorkflowOperationHelpers, input:
             conclusion: null;
             runId: null;
             url: null;
+            createdAt: null;
+            updatedAt: null;
         }[];
         releaseCandidate: ReleaseCandidateReport | null;
     } & {
@@ -886,6 +892,7 @@ export declare function workflowRelease(helpers: WorkflowOperationHelpers, input
         targetBranch: string;
         commitSha: string;
     };
+    hostedDeploymentState: Record<string, unknown>[];
     finalBranch: string;
     pushStatus: {
         stagingPushed: boolean;
@@ -905,6 +912,8 @@ export declare function workflowRelease(helpers: WorkflowOperationHelpers, input
         conclusion: null;
         runId: null;
         url: null;
+        createdAt: null;
+        updatedAt: null;
     }[];
 } & {
     finalState?: WorkflowStatePayload;
@@ -968,6 +977,7 @@ export declare function workflowRelease(helpers: WorkflowOperationHelpers, input
         targetBranch: string;
         commitSha: string;
     };
+    hostedDeploymentState: Record<string, unknown>[];
     finalBranch: string;
     pushStatus: {
         stagingPushed: boolean;
@@ -987,6 +997,8 @@ export declare function workflowRelease(helpers: WorkflowOperationHelpers, input
         conclusion: null;
         runId: null;
         url: null;
+        createdAt: null;
+        updatedAt: null;
     })[];
 } & {
     finalState?: WorkflowStatePayload;

package/dist/workflow/operations.js

@@ -36,6 +36,7 @@ import {
   ensureGeneratedWranglerConfig,
   finalizeDeploymentState,
   loadDeployState,
+  recordHostedDeploymentState,
   runRemoteD1Migrations,
   validateDeployPrerequisites,
   validateDestroyPrerequisites
@@ -418,6 +419,38 @@ async function waitForWorkflowGates(operation, gates, ciMode, options = {}) {
   }
   return results;
 }
+function recordHostedDeploymentStatesFromRootGates(root, rootRelease, workflowGates) {
+  const gates = Array.isArray(workflowGates) ? workflowGates.map((gate) => stringRecord(gate)).filter((gate) => Boolean(gate)) : [];
+  const releaseRecord = stringRecord(rootRelease) ?? {};
+  const reports = [];
+  for (const target of [
+    { scope: "staging", branch: STAGING_BRANCH, commit: releaseRecord.stagingCommit },
+    { scope: "prod", branch: PRODUCTION_BRANCH, commit: releaseRecord.releasedCommit }
+  ]) {
+    const gate = gates.find((candidate) => candidate.workflow === "deploy.yml" && candidate.branch === target.branch && candidate.status === "completed" && candidate.conclusion === "success");
+    const timestamp = typeof gate?.updatedAt === "string" && gate.updatedAt.trim() ? gate.updatedAt : null;
+    if (!gate || !timestamp) {
+      continue;
+    }
+    const state = recordHostedDeploymentState(root, {
+      scope: target.scope,
+      commit: typeof target.commit === "string" ? target.commit : null,
+      timestamp,
+      workflow: gate.workflow,
+      runId: gate.runId ?? null
+    });
+    reports.push({
+      scope: target.scope,
+      branch: target.branch,
+      commit: typeof target.commit === "string" ? target.commit : null,
+      timestamp: state.lastDeploymentTimestamp ?? timestamp,
+      url: state.lastDeployedUrl ?? null,
+      workflow: gate.workflow,
+      runId: gate.runId ?? null
+    });
+  }
+  return reports;
+}
 function ensureTreeseedCommandReadiness(root) {
   if (getGitHubAutomationMode() === "stub") {
     return {
@@ -3625,6 +3658,7 @@ async function workflowRelease(helpers, input) {
             runId: workflowRun.runId,
             onProgress: (line, stream) => helpers.write(line, stream)
           }).then((workflowGates) => ({ workflowGates })));
+          const hostedDeploymentState2 = recordHostedDeploymentStatesFromRootGates(root, rootRelease2, rootWorkflowGateResult2?.workflowGates);
           const releaseBackMerge2 = await executeJournalStep(root, workflowRun.runId, "release-back-merge", () => backMergeRootProductionIntoStaging(root, false));
           const workspaceLinks2 = ensureWorkflowWorkspaceLinks(root, helpers, effectiveInput.workspaceLinks ?? "auto");
           const payload2 = {
@@ -3648,6 +3682,7 @@ async function workflowRelease(helpers, input) {
             rootRepo,
             releaseCandidate,
             releaseBackMerge: releaseBackMerge2,
+            hostedDeploymentState: hostedDeploymentState2,
             finalBranch: currentBranch(gitRoot) || STAGING_BRANCH,
             pushStatus: { stagingPushed: true, productionPushed: true, tagPushed: true },
             workspaceLinks: workspaceLinks2,
@@ -3870,6 +3905,7 @@ async function workflowRelease(helpers, input) {
           runId: workflowRun.runId,
           onProgress: (line, stream) => helpers.write(line, stream)
         }).then((workflowGates) => ({ workflowGates })));
+        const hostedDeploymentState = recordHostedDeploymentStatesFromRootGates(root, rootRelease, rootWorkflowGateResult?.workflowGates);
         const releaseBackMerge = await executeJournalStep(root, workflowRun.runId, "release-back-merge", () => backMergeRootProductionIntoStaging(root, true));
         const devTagCleanupMode = effectiveInput.devTagCleanup ?? "safe-after-release";
         const devTagCleanup = devTagCleanupMode === "off" ? (skipJournalStep(root, workflowRun.runId, "cleanup-dev-tags", { status: "skipped", reason: "disabled" }), { status: "skipped", reason: "disabled" }) : await executeJournalStep(root, workflowRun.runId, "cleanup-dev-tags", () => {
@@ -3921,6 +3957,7 @@ async function workflowRelease(helpers, input) {
           rootRepo,
           releaseCandidate,
           releaseBackMerge,
+          hostedDeploymentState,
           finalBranch: currentBranch(gitRoot) || STAGING_BRANCH,
           pushStatus: {
             stagingPushed: true,

package/dist/workflow-state.d.ts

@@ -189,6 +189,7 @@ export type TreeseedWorkflowState = {
     releaseHistory: {
         stagingAheadMain: number | null;
         stagingBehindMain: number | null;
+        unreleasedStagingCommits: number | null;
         backMerged: boolean | null;
         detail: string;
     };

package/dist/workflow-state.js

@@ -261,6 +261,7 @@ function safeReleaseHistory(repoDir) {
     return {
       stagingAheadMain: null,
       stagingBehindMain: null,
+      unreleasedStagingCommits: null,
       backMerged: null,
       detail: "Repository root is unavailable."
     };
@@ -273,16 +274,20 @@ function safeReleaseHistory(repoDir) {
     if (!Number.isFinite(stagingAheadMain) || !Number.isFinite(stagingBehindMain)) {
       throw new Error("invalid rev-list output");
     }
+    const stagingOnlySubjects = run("git", ["log", "--format=%s", "main..staging"], { cwd: repoDir, capture: true }).split("\n").map((line) => line.trim()).filter(Boolean);
+    const unreleasedStagingCommits = stagingOnlySubjects.filter((subject) => subject !== "release: sync package staging heads" && subject !== "release: back-merge main into staging" && !subject.startsWith("release: back-merge main into staging ")).length;
     return {
       stagingAheadMain,
       stagingBehindMain,
+      unreleasedStagingCommits,
       backMerged: stagingBehindMain === 0,
-      detail: stagingBehindMain === 0 ? "Staging contains current main release history." : `Staging is missing ${stagingBehindMain} main commit${stagingBehindMain === 1 ? "" : "s"}.`
+      detail: stagingBehindMain === 0 && unreleasedStagingCommits === 0 ? stagingAheadMain > 0 ? "Staging contains current main release history and is only ahead by release sync commits." : "Staging contains current main release history." : stagingBehindMain === 0 ? `Staging has ${unreleasedStagingCommits} unreleased commit${unreleasedStagingCommits === 1 ? "" : "s"} and contains current main release history.` : `Staging is missing ${stagingBehindMain} main commit${stagingBehindMain === 1 ? "" : "s"}.`
     };
   } catch {
     return {
       stagingAheadMain: null,
       stagingBehindMain: null,
+      unreleasedStagingCommits: null,
       backMerged: null,
       detail: "Could not compare staging and main release history."
     };
@@ -414,6 +419,8 @@ function resolveTreeseedWorkflowState(cwd, options = {}) {
   if (interruptedRuns.length > 0) {
     workflowBlockers.push(`Interrupted workflow runs detected: ${interruptedRuns.map((run2) => run2.runId).join(", ")}.`);
   }
+  const releaseHistory = safeReleaseHistory(root);
+  const releaseReady = branchRole === "staging" && !dirtyWorktree && (releaseHistory.unreleasedStagingCommits ?? 0) > 0;
   const state = {
     cwd: effectiveCwd,
     workspaceRoot,
@@ -527,8 +534,8 @@ function resolveTreeseedWorkflowState(cwd, options = {}) {
       idleRemainingMs: keyStatus.idleRemainingMs,
       startupPassphraseConfigured: Boolean(process.env.TREESEED_KEY_PASSPHRASE?.trim())
     },
-    releaseReady: branchRole === "staging" && !dirtyWorktree,
-    releaseHistory: safeReleaseHistory(root),
+    releaseReady,
+    releaseHistory,
     readiness: {
       local: { ready: false, blockers: [], warnings: [] },
       staging: { ready: false, blockers: [], warnings: [] },
@@ -747,8 +754,13 @@ function recommendTreeseedNextSteps(state) {
     }
     if (!state.persistentEnvironments.staging.initialized) {
       recommendations.push({ operation: "config", reason: "Initialize the staging environment before releasing.", input: { environment: ["staging"] } });
+    } else if ((state.releaseHistory.unreleasedStagingCommits ?? 0) > 0) {
+      recommendations.push({ operation: "release", reason: "Promote unreleased staging commits into production.", input: { bump: "patch" } });
+      if (state.managedServices.api.enabled) {
+        recommendations.push({ operation: "auth:login", reason: "Keep the local runtime authenticated to the remote API used by managed services." });
+      }
     } else {
-      recommendations.push({ operation: "release", reason: "Promote staging into main when the integration branch is ready for production.", input: { bump: "patch" } });
+      recommendations.push({ operation: "status", reason: "Inspect staging and production state; no unreleased staging commits are pending." });
       if (state.managedServices.api.enabled) {
         recommendations.push({ operation: "auth:login", reason: "Keep the local runtime authenticated to the remote API used by managed services." });
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@treeseed/sdk",
-  "version": "0.6.33",
+  "version": "0.6.34",
   "description": "Shared Treeseed SDK for content-backed and D1-backed object models.",
   "license": "AGPL-3.0-only",
   "repository": {