@treeseed/sdk 0.10.5 → 0.10.7

package/dist/operations/services/runtime-tools.d.ts

@@ -175,9 +175,23 @@ export declare function loadCliDeployConfig(tenantRoot: any): {
                 projectName: string | undefined;
                 serviceId: string | undefined;
                 serviceName: string | undefined;
+                resourceType: string | undefined;
+                environmentVariable: string | undefined;
+                serviceTargets: any;
                 rootDir: string | undefined;
                 buildCommand: string | undefined;
                 startCommand: string | undefined;
+                healthcheckPath: string | undefined;
+                healthcheckTimeoutSeconds: number | undefined;
+                healthcheckIntervalSeconds: number | undefined;
+                restartPolicy: string | undefined;
+                runtimeMode: string | undefined;
+                volumeMountPath: string | undefined;
+                runnerPool: {
+                    bootstrapCount: number | undefined;
+                    maxRunners: number | undefined;
+                    volumeMountPath: string | undefined;
+                } | undefined;
                 schedule: any;
             };
             environments: {

package/dist/operations/services/runtime-tools.js

@@ -53,7 +53,7 @@ const TREESEED_DEFAULT_PROVIDER_SELECTIONS = {
   },
   site: "default"
 };
-const TRESEED_MANAGED_SERVICE_KEYS = ["api", "workdayManager", "workerRunner"];
+const TRESEED_MANAGED_SERVICE_KEYS = ["marketDatabase", "api", "marketOperationsRunner"];
 const TRESEED_WORKSPACE_PACKAGE_DIRS = ["sdk", "core", "cli"];
 const CLOUDFLARE_ACCOUNT_ID_PLACEHOLDER = "replace-with-cloudflare-account-id";
 function normalizePlanesFromLegacyHosting(hosting) {
@@ -143,9 +143,23 @@ function parseManagedServiceConfig(value, label) {
       projectName: optionalString(railway.projectName),
       serviceId: optionalString(railway.serviceId),
       serviceName: optionalString(railway.serviceName),
+      resourceType: optionalString(railway.resourceType),
+      environmentVariable: optionalString(railway.environmentVariable),
+      serviceTargets: Array.isArray(railway.serviceTargets) ? railway.serviceTargets.map((entry) => optionalString(entry)).filter(Boolean) : void 0,
       rootDir: optionalString(railway.rootDir),
       buildCommand: optionalString(railway.buildCommand),
       startCommand: optionalString(railway.startCommand),
+      healthcheckPath: optionalString(railway.healthcheckPath),
+      healthcheckTimeoutSeconds: optionalNonNegativeNumber(railway.healthcheckTimeoutSeconds, `${label}.railway.healthcheckTimeoutSeconds`),
+      healthcheckIntervalSeconds: optionalNonNegativeNumber(railway.healthcheckIntervalSeconds, `${label}.railway.healthcheckIntervalSeconds`),
+      restartPolicy: optionalString(railway.restartPolicy),
+      runtimeMode: optionalString(railway.runtimeMode),
+      volumeMountPath: optionalString(railway.volumeMountPath),
+      runnerPool: optionalRecord(railway.runnerPool, `${label}.railway.runnerPool`) ? {
+        bootstrapCount: optionalNonNegativeNumber(railway.runnerPool.bootstrapCount, `${label}.railway.runnerPool.bootstrapCount`),
+        maxRunners: optionalNonNegativeNumber(railway.runnerPool.maxRunners, `${label}.railway.runnerPool.maxRunners`),
+        volumeMountPath: optionalString(railway.runnerPool.volumeMountPath)
+      } : void 0,
       schedule: Array.isArray(railway.schedule) ? railway.schedule.map((entry) => optionalString(entry)).filter(Boolean) : optionalString(railway.schedule)
     },
     environments: {

package/dist/operations/services/workspace-save.d.ts

@@ -1,6 +1,23 @@
 export declare const MERGE_CONFLICT_EXIT_CODE = 12;
+export declare const TREESEED_PUBLIC_RELEASE_PACKAGE_NAMES: string[];
+export declare function highestStableGitTagOnLine(repoDir: any, lineLabel: any): string | null;
 export declare function incrementPatchVersion(version: any): string;
 export declare function incrementVersion(version: any, level?: string): string;
+export declare function collectPublicPackageReleaseLineState(root?: any): {
+    group: string[];
+    packages: {
+        name: any;
+        path: any;
+        version: string;
+        line: string;
+        major: number;
+        minor: number;
+    }[];
+    lines: string[];
+    highestLine: string | null;
+    aligned: boolean;
+    drifted: boolean;
+};
 export declare function planWorkspaceVersionChanges(root?: any): {
     packages: any[];
     publishable: Set<any>;
@@ -14,6 +31,13 @@ export declare function planWorkspaceReleaseBump(level?: string, root?: any, opt
     versions: Map<any, any>;
     level: string;
     selected: Set<any>;
+    releaseLine: {
+        group: string[];
+        repair: boolean;
+        targetLine: string;
+        highestCurrentLine: string;
+        alignedBefore: boolean;
+    };
 };
 export declare function collectWorkspaceVersionConsistencyIssues(root?: any): {
     packageName: any;

package/dist/operations/services/workspace-save.js

@@ -2,6 +2,7 @@ import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { resolve } from "node:path";
 import { changedWorkspacePackages, publishableWorkspacePackages, run, sortWorkspacePackages, workspacePackages, workspaceRoot } from "./workspace-tools.js";
 const MERGE_CONFLICT_EXIT_CODE = 12;
+const TREESEED_PUBLIC_RELEASE_PACKAGE_NAMES = ["@treeseed/sdk", "@treeseed/core", "@treeseed/cli", "@treeseed/agent"];
 function parseSemver(version) {
   const match = String(version).trim().match(/^(\d+)\.(\d+)\.(\d+)(?:-[0-9A-Za-z.-]+)?$/);
   if (!match) {
@@ -14,6 +15,82 @@ function parseSemver(version) {
     prerelease: String(version).includes("-")
   };
 }
+function versionLine(version) {
+  const parsed = parseSemver(version);
+  return {
+    major: parsed.major,
+    minor: parsed.minor,
+    label: `${parsed.major}.${parsed.minor}`
+  };
+}
+function compareVersionLines(left, right) {
+  if (left.major !== right.major) return left.major - right.major;
+  return left.minor - right.minor;
+}
+function parseVersionLine(input) {
+  const match = String(input ?? "").trim().match(/^(\d+)\.(\d+)$/);
+  if (!match) {
+    throw new Error(`Unsupported release version line "${input}". Expected major.minor, for example 0.10.`);
+  }
+  return {
+    major: Number(match[1]),
+    minor: Number(match[2]),
+    label: `${Number(match[1])}.${Number(match[2])}`
+  };
+}
+function nextLineFor(level, highestLine) {
+  if (level === "major") {
+    return {
+      major: highestLine.major + 1,
+      minor: 0,
+      label: `${highestLine.major + 1}.0`
+    };
+  }
+  if (level === "minor") {
+    return {
+      major: highestLine.major,
+      minor: highestLine.minor + 1,
+      label: `${highestLine.major}.${highestLine.minor + 1}`
+    };
+  }
+  return highestLine;
+}
+function versionForLine(line, patch = 0) {
+  return `${line.major}.${line.minor}.${patch}`;
+}
+function localGitTagExists(repoDir, tagName) {
+  try {
+    return run("git", ["tag", "--list", tagName], { cwd: repoDir, capture: true }).trim() === tagName;
+  } catch {
+    return false;
+  }
+}
+function highestStableGitTagOnLine(repoDir, lineLabel) {
+  const line = parseVersionLine(lineLabel);
+  try {
+    const tags = run("git", ["tag", "--list", `${line.label}.*`], { cwd: repoDir, capture: true }).split(/\r?\n/u).map((tag) => tag.trim()).filter(Boolean).map((tag) => {
+      try {
+        const parsed = parseSemver(tag);
+        if (parsed.prerelease || parsed.major !== line.major || parsed.minor !== line.minor) return null;
+        return { tag, patch: parsed.patch };
+      } catch {
+        return null;
+      }
+    }).filter((entry) => entry != null).sort((left, right) => right.patch - left.patch);
+    return tags[0]?.tag ?? null;
+  } catch {
+    return null;
+  }
+}
+function firstAvailablePatchVersionOnLine(pkg, line) {
+  for (let patch = 0; patch < 1e3; patch += 1) {
+    const candidate = versionForLine(line, patch);
+    if (!localGitTagExists(pkg.dir, candidate)) {
+      return candidate;
+    }
+  }
+  throw new Error(`Unable to find an available ${line.label}.x version for ${pkg.name}.`);
+}
 function incrementPatchVersion(version) {
   const parsed = parseSemver(version);
   return `${parsed.major}.${parsed.minor}.${parsed.patch + 1}`;
@@ -34,6 +111,32 @@ function incrementVersion(version, level = "patch") {
   }
   throw new Error(`Unsupported release bump "${level}". Expected major, minor, or patch.`);
 }
+function collectPublicPackageReleaseLineState(root = workspaceRoot()) {
+  const publishable = new Set(publishableWorkspacePackages(root).map((pkg) => pkg.name));
+  const packages = sortWorkspacePackages(workspacePackages(root)).filter((pkg) => TREESEED_PUBLIC_RELEASE_PACKAGE_NAMES.includes(pkg.name)).filter((pkg) => publishable.has(pkg.name)).map((pkg) => {
+    const packageJson = readPackageJson(resolve(pkg.dir, "package.json"));
+    const line = versionLine(packageJson.version);
+    return {
+      name: pkg.name,
+      path: pkg.relativeDir,
+      version: String(packageJson.version ?? ""),
+      line: line.label,
+      major: line.major,
+      minor: line.minor
+    };
+  });
+  const lineMap = new Map(packages.map((pkg) => [pkg.line, { major: pkg.major, minor: pkg.minor, label: pkg.line }]));
+  const lines = [...lineMap.values()].sort(compareVersionLines);
+  const highestLine = lines.at(-1) ?? null;
+  return {
+    group: TREESEED_PUBLIC_RELEASE_PACKAGE_NAMES.filter((name) => packages.some((pkg) => pkg.name === name)),
+    packages,
+    lines: lines.map((line) => line.label),
+    highestLine: highestLine?.label ?? null,
+    aligned: lines.length <= 1,
+    drifted: lines.length > 1
+  };
+}
 function readPackageJson(filePath) {
   return JSON.parse(readFileSync(filePath, "utf8"));
 }
@@ -124,16 +227,43 @@ function planWorkspaceReleaseBump(level = "patch", root = workspaceRoot(), optio
     packageJson: readPackageJson(resolve(pkg.dir, "package.json"))
   }));
   const publishable = new Set(publishableWorkspacePackages(root).map((pkg) => pkg.name));
-  const selected = options.selectedPackageNames ? new Set(
+  const baseSelected = options.selectedPackageNames ? new Set(
     [...options.selectedPackageNames].map((name) => String(name)).filter((name) => publishable.has(name))
   ) : new Set(publishable);
+  const publicPackages = sortWorkspacePackages(packages).filter((pkg) => TREESEED_PUBLIC_RELEASE_PACKAGE_NAMES.includes(pkg.name)).filter((pkg) => publishable.has(pkg.name));
+  const publicLines = publicPackages.map((pkg) => versionLine(pkg.packageJson.version));
+  const highestPublicLine = publicLines.sort(compareVersionLines).at(-1) ?? { major: 0, minor: 0, label: "0.0" };
+  const repairVersionLine = options.repairVersionLine === true;
+  const explicitTargetLine = options.targetVersionLine ? parseVersionLine(options.targetVersionLine) : null;
+  let targetLine = explicitTargetLine ?? highestPublicLine;
+  if (repairVersionLine) {
+    if (explicitTargetLine && compareVersionLines(explicitTargetLine, highestPublicLine) !== 0) {
+      throw new Error(`Release line repair target must match the highest current public package line (${highestPublicLine.label}). Received ${explicitTargetLine.label}.`);
+    }
+  } else if (level === "major" || level === "minor") {
+    targetLine = nextLineFor(level, highestPublicLine);
+  }
+  const selected = new Set(baseSelected);
+  if (repairVersionLine) {
+    selected.clear();
+    for (const pkg of publicPackages) {
+      if (versionLine(pkg.packageJson.version).label !== targetLine.label) {
+        selected.add(pkg.name);
+      }
+    }
+  } else if (level === "major" || level === "minor") {
+    for (const pkg of publicPackages) {
+      selected.add(pkg.name);
+    }
+  }
   const touched = /* @__PURE__ */ new Set();
   const versions = /* @__PURE__ */ new Map();
   for (const pkg of packages) {
     if (!publishable.has(pkg.name) || !selected.has(pkg.name)) {
       continue;
     }
-    const nextVersion = incrementVersion(pkg.packageJson.version, level);
+    const isPublicReleasePackage = TREESEED_PUBLIC_RELEASE_PACKAGE_NAMES.includes(pkg.name);
+    const nextVersion = repairVersionLine && isPublicReleasePackage ? firstAvailablePatchVersionOnLine(pkg, targetLine) : isPublicReleasePackage && (level === "major" || level === "minor") ? versionForLine(targetLine, 0) : incrementVersion(pkg.packageJson.version, level);
     pkg.packageJson.version = nextVersion;
     versions.set(pkg.name, nextVersion);
     touched.add(pkg.name);
@@ -157,7 +287,14 @@ function planWorkspaceReleaseBump(level = "patch", root = workspaceRoot(), optio
     touched,
     versions,
     level,
-    selected
+    selected,
+    releaseLine: {
+      group: TREESEED_PUBLIC_RELEASE_PACKAGE_NAMES.filter((name) => publishable.has(name)),
+      repair: repairVersionLine,
+      targetLine: targetLine.label,
+      highestCurrentLine: highestPublicLine.label,
+      alignedBefore: new Set(publicLines.map((line) => line.label)).size <= 1
+    }
   };
 }
 function collectWorkspaceVersionConsistencyIssues(root = workspaceRoot()) {
@@ -272,15 +409,18 @@ function formatMergeConflictReport(report, repoDir, targetBranch = "main") {
 }
 export {
   MERGE_CONFLICT_EXIT_CODE,
+  TREESEED_PUBLIC_RELEASE_PACKAGE_NAMES,
   applyWorkspaceVersionChanges,
   assertWorkspaceVersionConsistency,
   collectMergeConflictReport,
+  collectPublicPackageReleaseLineState,
   collectWorkspaceVersionConsistencyIssues,
   countConflictMarkers,
   currentBranch,
   formatMergeConflictReport,
   gitStatusPorcelain,
   hasMeaningfulChanges,
+  highestStableGitTagOnLine,
   incrementPatchVersion,
   incrementVersion,
   originRemoteUrl,

package/dist/operations/services/workspace-tools.js

@@ -1,7 +1,7 @@
 import { existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, rmSync } from "node:fs";
 import { spawnSync } from "node:child_process";
 import { join, relative, resolve } from "node:path";
-const TREESEED_WORKSPACE_PACKAGE_DIRS = ["sdk", "core", "cli"];
+const TREESEED_WORKSPACE_PACKAGE_DIRS = ["sdk", "core", "cli", "agent"];
 function packageSortWeight(pkg) {
   const relativeDir = String(pkg.relativeDir ?? "");
   const dirName = relativeDir.split("/").pop() ?? "";

package/dist/platform/env.yaml

@@ -23,6 +23,32 @@ entries:
     sourcePriority:
       - machine-config
       - process-env
+  RAILWAY_API_TOKEN:
+    label: Railway API token
+    group: auth
+    description: Account-level Railway API token used by Treeseed to provision, reconcile, deploy, and inspect Market Railway services.
+    howToGet: Create a Railway account API token with access to the Treeseed Market project/workspace, then store it through Treeseed config as RAILWAY_API_TOKEN.
+    sensitivity: secret
+    targets:
+      - local-runtime
+      - github-secret
+    scopes:
+      - local
+      - staging
+      - prod
+    storage: shared
+    requirement: required
+    purposes:
+      - deploy
+      - config
+    validation:
+      kind: nonempty
+      minLength: 8
+    sourcePriority:
+      - machine-config
+      - process-env
+    relevanceRef: railwayManagedEnabled
+    requiredWhenRef: railwayManagedEnabled
   TREESEED_GITHUB_OWNER:
     label: GitHub repository owner
     group: github
@@ -351,7 +377,7 @@ entries:
       - staging
       - prod
     storage: shared
-    requirement: conditional
+    requirement: optional
     purposes:
       - deploy
       - config
@@ -364,6 +390,142 @@ entries:
     relevanceRef: projectRegistrationEnabled
     requiredWhenRef: projectRegistrationEnabled
     defaultValueRef: marketBaseUrlDefault
+  TREESEED_MARKET_DATABASE_URL:
+    label: Market PostgreSQL database URL
+    group: hosting
+    cluster: hosting:market-control-plane
+    visibility: system
+    description: Railway PostgreSQL connection URL for Market control-plane tables. Browser/UI code must never receive this value.
+    howToGet: Provision the managed Market PostgreSQL resource through Treeseed/Railway reconciliation and store the generated connection URL as a service secret.
+    sensitivity: secret
+    targets:
+      - railway-secret
+    serviceTargets:
+      - api
+      - marketOperationsRunner
+    scopes:
+      - staging
+      - prod
+    storage: scoped
+    requirement: optional
+    purposes:
+      - deploy
+      - config
+    validation:
+      kind: url
+    sourcePriority:
+      - machine-config
+      - process-env
+      - treeseed.site.yaml
+  TREESEED_PLATFORM_RUNNER_SECRET:
+    label: Market operations runner secret
+    group: hosting
+    cluster: hosting:market-operations-runner
+    visibility: system
+    description: Bearer credential used only by the TreeSeed-owned Market operations runner to claim and update platform operation jobs.
+    howToGet: Generate a strong secret with `openssl rand -base64 48` and store it through `treeseed config` for staging and production.
+    sensitivity: secret
+    targets:
+      - railway-secret
+    serviceTargets:
+      - api
+      - marketOperationsRunner
+    scopes:
+      - staging
+      - prod
+    storage: scoped
+    requirement: conditional
+    purposes:
+      - deploy
+      - config
+    validation:
+      kind: nonempty
+      minLength: 24
+    sourcePriority:
+      - machine-config
+      - process-env
+    defaultValueRef: generatedSecret
+  TREESEED_PLATFORM_RUNNER_ID:
+    label: Market operations runner ID
+    group: hosting
+    cluster: hosting:market-operations-runner
+    visibility: system
+    description: Stable identity for the TreeSeed-owned Market operations runner service in each environment.
+    howToGet: Treeseed derives this from the environment. Override it only when replacing a runner identity deliberately.
+    sensitivity: plain
+    targets:
+      - railway-var
+    serviceTargets:
+      - marketOperationsRunner
+    scopes:
+      - staging
+      - prod
+    storage: scoped
+    requirement: conditional
+    purposes:
+      - deploy
+      - config
+    validation:
+      kind: nonempty
+    sourcePriority:
+      - machine-config
+      - process-env
+      - treeseed.site.yaml
+    defaultValueRef: platformRunnerIdDefault
+  TREESEED_PLATFORM_RUNNER_DATA_DIR:
+    label: Market operations runner data directory
+    group: hosting
+    cluster: hosting:market-operations-runner
+    visibility: system
+    description: Writable data directory mounted into the Market operations runner for repository workspaces and operation state.
+    howToGet: Use `/data` for Railway runner services with an attached volume.
+    sensitivity: plain
+    targets:
+      - railway-var
+    serviceTargets:
+      - marketOperationsRunner
+    scopes:
+      - staging
+      - prod
+    storage: scoped
+    requirement: conditional
+    purposes:
+      - deploy
+      - config
+    validation:
+      kind: nonempty
+    sourcePriority:
+      - machine-config
+      - process-env
+      - treeseed.site.yaml
+    defaultValueRef: platformRunnerDataDirDefault
+  TREESEED_PLATFORM_RUNNER_ENVIRONMENT:
+    label: Market operations runner environment
+    group: hosting
+    cluster: hosting:market-operations-runner
+    visibility: system
+    description: Runtime environment label reported by the Market operations runner in registration and heartbeat records.
+    howToGet: Treeseed derives this from the selected environment.
+    sensitivity: plain
+    targets:
+      - railway-var
+    serviceTargets:
+      - marketOperationsRunner
+    scopes:
+      - staging
+      - prod
+    storage: scoped
+    requirement: conditional
+    purposes:
+      - deploy
+      - config
+    validation:
+      kind: nonempty
+    sourcePriority:
+      - machine-config
+      - process-env
+      - treeseed.site.yaml
+    defaultValueRef: platformRunnerEnvironmentDefault
   TREESEED_CATALOG_MARKET_API_BASE_URLS:
     label: Treeseed catalog market API URLs
     group: hosting
@@ -439,4 +601,3 @@ entries:
     relevanceRef: projectRegistrationEnabled
     requiredWhenRef: projectRegistrationEnabled
     defaultValueRef: hostingProjectIdDefault
-

package/dist/platform/environment.d.ts

@@ -75,6 +75,7 @@ export type TreeseedEnvironmentEntry = {
     howToGet: string;
     sensitivity: TreeseedEnvironmentSensitivity;
     targets: TreeseedEnvironmentTarget[];
+    serviceTargets?: string[];
     scopes: TreeseedEnvironmentScope[];
     requirement: TreeseedEnvironmentRequirement;
     purposes: TreeseedEnvironmentPurpose[];

package/dist/platform/environment.js

@@ -258,6 +258,12 @@ function resolveHostedProjectId(context) {
 function resolveRailwayWorkspaceDefault() {
   return "knowledge-coop";
 }
+function resolvePlatformRunnerIdDefault(_context, scope) {
+  return scope === "prod" ? "market-ops-prod-1" : scope === "staging" ? "market-ops-staging-1" : "market-ops-local-1";
+}
+function resolvePlatformRunnerEnvironmentDefault(_context, scope) {
+  return scope === "prod" ? "production" : scope;
+}
 function parseGitHubRepositorySlugFromRemote(remoteUrl) {
   const normalized = String(remoteUrl ?? "").trim();
   const sshMatch = normalized.match(/^git@github\.com:([^/]+)\/(.+?)(?:\.git)?$/u);
@@ -312,6 +318,9 @@ const VALUE_RESOLVERS = {
   hostingTeamIdDefault: (context) => resolveHostedTeamId(context),
   hostingProjectIdDefault: (context) => resolveHostedProjectId(context),
   railwayWorkspaceDefault: () => resolveRailwayWorkspaceDefault(),
+  platformRunnerIdDefault: (context, scope) => resolvePlatformRunnerIdDefault(context, scope),
+  platformRunnerEnvironmentDefault: (context, scope) => resolvePlatformRunnerEnvironmentDefault(context, scope),
+  platformRunnerDataDirDefault: () => "/data",
   githubOwnerDefault: (context) => resolveGitHubOwnerDefault(context),
   githubRepositoryNameDefault: (context) => resolveGitHubRepositoryNameDefault(context),
   githubRepositoryVisibilityDefault: () => "private",

package/dist/platform-operation-store.d.ts

@@ -0,0 +1,90 @@
+import { type PlatformOperation, type PlatformOperationEvent, type PlatformRunnerClaimRequest, type PlatformRunnerHeartbeatRequest, type PlatformRunnerJobUpdateRequest, type PlatformRunnerRegistrationRequest } from './platform-operations.ts';
+export type DatabaseProvider = 'd1' | 'sqlite' | 'postgres';
+export interface RelationalDatabaseAdapter {
+    readonly provider: DatabaseProvider;
+    run(query: string, params?: unknown[]): Promise<void>;
+    first<T = Record<string, unknown>>(query: string, params?: unknown[]): Promise<T | null>;
+    all<T = Record<string, unknown>>(query: string, params?: unknown[]): Promise<T[]>;
+    exec?(query: string): Promise<void>;
+    transaction?<T>(callback: () => Promise<T>): Promise<T>;
+    close?(): Promise<void> | void;
+}
+export interface PlatformOperationStoreOptions {
+    database: RelationalDatabaseAdapter;
+    initializeSchema?: boolean;
+    now?: () => Date;
+}
+export interface CreatePlatformOperationStoreFromEnvOptions {
+    databaseUrl?: string | null;
+    initializeSchema?: boolean;
+}
+export declare const PLATFORM_OPERATION_SCHEMA_SQL = "\nCREATE TABLE IF NOT EXISTS platform_operations (\n\tid TEXT PRIMARY KEY,\n\tnamespace TEXT NOT NULL,\n\toperation TEXT NOT NULL,\n\tstatus TEXT NOT NULL,\n\ttarget TEXT NOT NULL,\n\tidempotency_key TEXT,\n\tinput_json TEXT NOT NULL DEFAULT '{}',\n\toutput_json TEXT,\n\terror_json TEXT,\n\trequested_by_type TEXT NOT NULL,\n\trequested_by_id TEXT,\n\tassigned_runner_id TEXT,\n\tlease_expires_at TEXT,\n\tcreated_at TEXT NOT NULL,\n\tupdated_at TEXT NOT NULL,\n\tstarted_at TEXT,\n\tfinished_at TEXT,\n\tcancelled_at TEXT\n);\n\nCREATE UNIQUE INDEX IF NOT EXISTS idx_platform_operations_idempotency\n\tON platform_operations(namespace, operation, idempotency_key)\n\tWHERE idempotency_key IS NOT NULL;\n\nCREATE INDEX IF NOT EXISTS idx_platform_operations_runnable\n\tON platform_operations(status, created_at ASC);\n\nCREATE TABLE IF NOT EXISTS platform_operation_events (\n\tid TEXT PRIMARY KEY,\n\toperation_id TEXT NOT NULL,\n\tseq INTEGER NOT NULL,\n\tkind TEXT NOT NULL,\n\tdata_json TEXT NOT NULL DEFAULT '{}',\n\tcreated_at TEXT NOT NULL,\n\tFOREIGN KEY (operation_id) REFERENCES platform_operations(id) ON DELETE CASCADE\n);\n\nCREATE UNIQUE INDEX IF NOT EXISTS idx_platform_operation_events_seq\n\tON platform_operation_events(operation_id, seq);\n\nCREATE TABLE IF NOT EXISTS market_operation_runners (\n\tid TEXT PRIMARY KEY,\n\trunner_key TEXT NOT NULL UNIQUE,\n\tname TEXT NOT NULL,\n\tenvironment TEXT NOT NULL,\n\tstatus TEXT NOT NULL DEFAULT 'online',\n\tversion TEXT,\n\tcapabilities_json TEXT NOT NULL DEFAULT '[]',\n\tactive_job_count INTEGER NOT NULL DEFAULT 0,\n\tmax_concurrent_jobs INTEGER NOT NULL DEFAULT 1,\n\theartbeat_at TEXT,\n\tmetadata_json TEXT NOT NULL DEFAULT '{}',\n\tcreated_at TEXT NOT NULL,\n\tupdated_at TEXT NOT NULL\n);\n\nCREATE TABLE IF NOT EXISTS platform_repository_claims (\n\tid TEXT PRIMARY KEY,\n\trepository_key TEXT NOT NULL,\n\trunner_id TEXT NOT NULL,\n\tworkspace_path TEXT NOT NULL,\n\tbranch TEXT,\n\tcommit_sha TEXT,\n\tclaim_state TEXT NOT NULL DEFAULT 'active',\n\tlease_expires_at TEXT,\n\tmetadata_json TEXT NOT NULL DEFAULT '{}',\n\tcreated_at TEXT NOT NULL,\n\tupdated_at TEXT NOT NULL\n);\n\nCREATE UNIQUE INDEX IF NOT EXISTS idx_platform_repository_claims_active\n\tON platform_repository_claims(repository_key, runner_id)\n\tWHERE claim_state = 'active';\n\nCREATE INDEX IF NOT EXISTS idx_platform_repository_claims_runner\n\tON platform_repository_claims(runner_id, claim_state);\n";
+export declare function createD1RelationalAdapter(db: {
+    prepare(query: string): {
+        bind(...values: unknown[]): {
+            run(): Promise<unknown>;
+            first<T = Record<string, unknown>>(): Promise<T | null>;
+            all<T = Record<string, unknown>>(): Promise<{
+                results?: T[];
+            } | T[]>;
+        };
+    };
+    exec?(query: string): Promise<unknown>;
+}): RelationalDatabaseAdapter;
+export declare function createSqliteRelationalAdapter(path?: string | null): RelationalDatabaseAdapter;
+export declare function createPostgresRelationalAdapter(databaseUrl: string): Promise<RelationalDatabaseAdapter>;
+export declare function createRelationalAdapterFromUrl(databaseUrl: string): Promise<RelationalDatabaseAdapter>;
+export declare function createPlatformOperationStoreFromEnv(options?: CreatePlatformOperationStoreFromEnvOptions): Promise<PlatformOperationStore>;
+export declare class PlatformOperationStore {
+    private initialized;
+    private readonly database;
+    private readonly now;
+    private readonly initializeSchema;
+    constructor(options: PlatformOperationStoreOptions);
+    close(): Promise<void>;
+    ensureInitialized(): Promise<void>;
+    private appendPlatformOperationEvent;
+    register(request: PlatformRunnerRegistrationRequest): Promise<{
+        ok: true;
+        runner: Record<string, unknown> | null;
+    }>;
+    heartbeat(request: PlatformRunnerHeartbeatRequest): Promise<{
+        ok: true;
+        runner: Record<string, unknown> | null;
+    }>;
+    private upsertRunner;
+    getOperation(operationId: string): Promise<{
+        ok: true;
+        operation: PlatformOperation;
+    }>;
+    claimJob(input: PlatformRunnerClaimRequest): Promise<{
+        ok: true;
+        operation: PlatformOperation | null;
+    }>;
+    private assertRunnerUpdate;
+    appendEvent(operationId: string, request: PlatformRunnerJobUpdateRequest): Promise<{
+        ok: true;
+        event: PlatformOperationEvent;
+    }>;
+    renewLease(operationId: string, request: PlatformRunnerJobUpdateRequest & {
+        leaseSeconds?: number;
+    }): Promise<{
+        ok: true;
+        operation: PlatformOperation;
+    }>;
+    checkpoint(operationId: string, request: PlatformRunnerJobUpdateRequest): Promise<{
+        ok: true;
+        operation: PlatformOperation;
+    }>;
+    complete(operationId: string, request: PlatformRunnerJobUpdateRequest): Promise<{
+        ok: true;
+        operation: PlatformOperation;
+    }>;
+    fail(operationId: string, request: PlatformRunnerJobUpdateRequest): Promise<{
+        ok: true;
+        operation: PlatformOperation;
+    }>;
+    private upsertRepositoryClaim;
+    private renewRepositoryClaimsForRunner;
+    private releaseRepositoryClaimsForRunner;
+}