@treeseed/sdk 0.13.0-rc.2 → 0.13.0-rc.21

package/dist/content/content-store.js

@@ -1,269 +0,0 @@
-import crypto from "node:crypto";
-import { mkdir, readdir, readFile, stat, writeFile } from "node:fs/promises";
-import path from "node:path";
-import { resolveModelDefinition } from "../entrypoints/models/model-registry.js";
-import { canonicalizeFrontmatter, normalizeFilterFields, normalizeMutationData, normalizeRecordToCanonicalShape, normalizeSortFields, readCanonicalFieldValue } from "../entrypoints/models/sdk-fields.js";
-import { applyFilters, applySort } from "../entrypoints/models/sdk-filters.js";
-import { assertExpectedVersion } from "../packages/sdk-version.js";
-import { GitRuntime } from "../repositories/git-runtime.js";
-import { parseFrontmatterDocument, serializeFrontmatterDocument } from "./frontmatter.js";
-function pickSortForStrategy(definition, request) {
-  switch (request.strategy) {
-    case "oldest":
-      return [{ field: definition.pickField, direction: "asc" }];
-    case "highest_priority":
-      if (definition.sortableFields.includes("priority") || definition.filterableFields.includes("priority")) {
-        return [
-          { field: "priority", direction: "desc" },
-          { field: definition.pickField, direction: "desc" }
-        ];
-      }
-      return [{ field: definition.pickField, direction: "desc" }];
-    case "latest":
-    default:
-      return [{ field: definition.pickField, direction: "desc" }];
-  }
-}
-async function walkMarkdownFiles(root) {
-  try {
-    const entries = await readdir(root, { withFileTypes: true });
-    const files = await Promise.all(
-      entries.map(async (entry) => {
-        const fullPath = path.join(root, entry.name);
-        if (entry.isDirectory()) {
-          return walkMarkdownFiles(fullPath);
-        }
-        if (entry.isFile() && /\.(md|mdx)$/i.test(entry.name)) {
-          return [fullPath];
-        }
-        return [];
-      })
-    );
-    return files.flat();
-  } catch {
-    return [];
-  }
-}
-async function findWorktreeRoots(root) {
-  const entries = await readdir(root, { withFileTypes: true }).catch(() => []);
-  const names = new Set(entries.map((entry) => entry.name));
-  const nested = await Promise.all(
-    entries.filter((entry) => entry.isDirectory()).map((entry) => findWorktreeRoots(path.join(root, entry.name)))
-  );
-  return [
-    ...names.has(".git") ? [root] : [],
-    ...nested.flat()
-  ];
-}
-function inferSlug(filePath, root) {
-  const relativePath = path.relative(root, filePath).replace(/\\/g, "/");
-  return relativePath.replace(/\.(md|mdx)$/i, "");
-}
-async function readContentEntry(definition, filePath, contentDir) {
-  const source = await readFile(filePath, "utf8");
-  const parsed = parseFrontmatterDocument(source);
-  const fileStats = await stat(filePath);
-  const slug = inferSlug(filePath, contentDir);
-  const titleField = definition.fields.title ? readCanonicalFieldValue(definition, { frontmatter: parsed.frontmatter }, "title") : void 0;
-  const createdField = definition.fields.created_at ? readCanonicalFieldValue(definition, { frontmatter: parsed.frontmatter }, "created_at") : void 0;
-  const updatedField = definition.fields.updated_at ? readCanonicalFieldValue(definition, { frontmatter: parsed.frontmatter }, "updated_at") : void 0;
-  const nameField = definition.fields.name ? readCanonicalFieldValue(definition, { frontmatter: parsed.frontmatter }, "name") : void 0;
-  return {
-    id: slug,
-    slug,
-    model: definition.name,
-    title: typeof titleField === "string" ? String(titleField) : typeof nameField === "string" ? String(nameField) : void 0,
-    path: filePath,
-    body: parsed.body,
-    frontmatter: parsed.frontmatter,
-    createdAt: typeof createdField === "string" ? String(createdField) : fileStats.birthtime.toISOString(),
-    updatedAt: typeof updatedField === "string" ? String(updatedField) : fileStats.mtime.toISOString()
-  };
-}
-function entryMatchesIdentity(entry, request) {
-  return [request.id, request.slug, request.key].filter(Boolean).includes(entry.id);
-}
-function ensureMutationAllowed(definition, operation) {
-  if (!definition.operations.includes(operation)) {
-    throw new Error(`Model "${definition.name}" does not allow ${operation}.`);
-  }
-}
-function sanitizeFrontmatterInput(data) {
-  const next = { ...data };
-  delete next.body;
-  delete next.branchPrefix;
-  return next;
-}
-class ContentStore {
-  constructor(repoRoot, database, models) {
-    this.repoRoot = repoRoot;
-    this.database = database;
-    this.models = models;
-    this.gitRuntime = new GitRuntime(
-      repoRoot,
-      process.env.TREESEED_AGENT_DISABLE_GIT === "true"
-    );
-  }
-  repoRoot;
-  database;
-  models;
-  gitRuntime;
-  async list(model) {
-    const definition = resolveModelDefinition(model, this.models);
-    if (definition.storage !== "content" || !definition.contentDir) {
-      throw new Error(`Model "${model}" is not content-backed.`);
-    }
-    const roots = [
-      {
-        contentDir: definition.contentDir
-      }
-    ];
-    const worktreeRoot = path.join(this.repoRoot, ".agent-worktrees");
-    const worktrees = await findWorktreeRoots(worktreeRoot);
-    const relativeContentDir = path.relative(this.repoRoot, definition.contentDir);
-    for (const worktree of worktrees) {
-      roots.push({
-        contentDir: path.join(worktree, relativeContentDir)
-      });
-    }
-    const files = (await Promise.all(roots.map((root) => walkMarkdownFiles(root.contentDir)))).flat();
-    const entries = await Promise.all(
-      files.map(async (filePath) => {
-        const matchingRoot = roots.find((root) => filePath.startsWith(root.contentDir));
-        return readContentEntry(definition, filePath, matchingRoot?.contentDir ?? definition.contentDir);
-      })
-    );
-    const deduped = /* @__PURE__ */ new Map();
-    for (const entry of entries) {
-      const existing = deduped.get(entry.id);
-      if (!existing || new Date(entry.updatedAt ?? 0).valueOf() >= new Date(existing.updatedAt ?? 0).valueOf()) {
-        deduped.set(entry.id, entry);
-      }
-    }
-    return [...deduped.values()];
-  }
-  async get(request) {
-    const entries = await this.list(request.model);
-    return entries.find((entry) => entryMatchesIdentity(entry, request)) ?? null;
-  }
-  async search(request) {
-    const definition = resolveModelDefinition(request.model, this.models);
-    const items = await this.list(request.model);
-    const filtered = applyFilters(items, normalizeFilterFields(definition, request.filters), definition);
-    const sorted = applySort(filtered, normalizeSortFields(definition, request.sort), definition);
-    return sorted.slice(0, request.limit ?? sorted.length);
-  }
-  async follow(request) {
-    const items = await this.search({
-      model: request.model,
-      filters: [
-        ...request.filters ?? [],
-        {
-          field: "updatedAt",
-          op: "updated_since",
-          value: request.since
-        }
-      ]
-    });
-    return {
-      items,
-      since: request.since
-    };
-  }
-  async pick(request) {
-    const definition = resolveModelDefinition(request.model, this.models);
-    const sorted = await this.search({
-      model: request.model,
-      filters: request.filters,
-      sort: pickSortForStrategy(definition, request),
-      limit: 25
-    });
-    for (const item of sorted) {
-      const lease = await this.database.tryClaimContentLease({
-        model: definition.name,
-        itemKey: item.id,
-        claimedBy: request.workerId,
-        leaseSeconds: request.leaseSeconds
-      });
-      if (lease) {
-        return {
-          item,
-          leaseToken: lease
-        };
-      }
-    }
-    return {
-      item: null,
-      leaseToken: null
-    };
-  }
-  async create(request) {
-    const definition = resolveModelDefinition(request.model, this.models);
-    ensureMutationAllowed(definition, "create");
-    if (!definition.contentDir) {
-      throw new Error(`Model "${request.model}" is not content-backed.`);
-    }
-    const slug = String(request.data.slug ?? request.data.id ?? crypto.randomUUID());
-    const extension = definition.name === "knowledge" ? ".md" : ".mdx";
-    const body = typeof request.data.body === "string" ? request.data.body : "";
-    const branchName = `${String(request.data.branchPrefix ?? "agent")}/${definition.name}-${slug}`;
-    const worktreePath = await this.gitRuntime.ensureWorktree(branchName);
-    const contentDirInWorktree = path.join(worktreePath, path.relative(this.repoRoot, definition.contentDir));
-    const relativePath = path.relative(this.repoRoot, path.join(definition.contentDir, `${slug}${extension}`));
-    const filePath = path.join(worktreePath, relativePath);
-    const mutationData = normalizeMutationData(definition, sanitizeFrontmatterInput(request.data));
-    const frontmatter = canonicalizeFrontmatter(definition, {}, {
-      ...mutationData,
-      slug,
-      updated_at: mutationData.updated_at ?? (/* @__PURE__ */ new Date()).toISOString()
-    });
-    await mkdir(path.dirname(filePath), { recursive: true });
-    await writeFile(filePath, serializeFrontmatterDocument(frontmatter, body), "utf8");
-    const git = await this.gitRuntime.commitFileChange(
-      filePath,
-      branchName,
-      `agent(${definition.name}): create ${slug}`
-    );
-    return {
-      item: await readContentEntry(definition, filePath, contentDirInWorktree),
-      git
-    };
-  }
-  async update(request) {
-    const definition = resolveModelDefinition(request.model, this.models);
-    ensureMutationAllowed(definition, "update");
-    const existing = await this.get(request);
-    if (!existing) {
-      throw new Error(`No ${request.model} entry found for update.`);
-    }
-    assertExpectedVersion(request.expectedVersion, existing, `${definition.name} "${existing.slug}"`);
-    const branchName = `${String(request.data.branchPrefix ?? "agent")}/${definition.name}-${existing.slug}`;
-    const worktreePath = await this.gitRuntime.ensureWorktree(branchName);
-    const relativePath = path.relative(this.repoRoot, existing.path);
-    const targetPath = path.join(worktreePath, relativePath);
-    const mutationData = normalizeMutationData(definition, sanitizeFrontmatterInput(request.data));
-    const nextFrontmatter = canonicalizeFrontmatter(
-      definition,
-      normalizeRecordToCanonicalShape(definition, existing.frontmatter),
-      {
-        ...mutationData,
-        updated_at: mutationData.updated_at ?? (/* @__PURE__ */ new Date()).toISOString()
-      }
-    );
-    const nextBody = typeof request.data.body === "string" ? request.data.body : existing.body;
-    await mkdir(path.dirname(targetPath), { recursive: true });
-    await writeFile(targetPath, serializeFrontmatterDocument(nextFrontmatter, nextBody), "utf8");
-    const git = await this.gitRuntime.commitFileChange(
-      targetPath,
-      branchName,
-      `agent(${definition.name}): update ${existing.slug}`
-    );
-    return {
-      item: await readContentEntry(definition, targetPath, path.join(worktreePath, path.relative(this.repoRoot, definition.contentDir))),
-      git
-    };
-  }
-}
-export {
-  ContentStore
-};

package/dist/content/frontmatter.d.ts

@@ -1,6 +0,0 @@
-export interface ParsedMarkdownDocument {
-    frontmatter: Record<string, unknown>;
-    body: string;
-}
-export declare function parseFrontmatterDocument(source: string): ParsedMarkdownDocument;
-export declare function serializeFrontmatterDocument(frontmatter: Record<string, unknown>, body: string): string;

package/dist/content/frontmatter.js

@@ -1,33 +0,0 @@
-import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
-function parseFrontmatterDocument(source) {
-  if (!source.startsWith("---\n")) {
-    return {
-      frontmatter: {},
-      body: source
-    };
-  }
-  const delimiterIndex = source.indexOf("\n---\n", 4);
-  if (delimiterIndex < 0) {
-    return {
-      frontmatter: {},
-      body: source
-    };
-  }
-  const yamlSource = source.slice(4, delimiterIndex);
-  const body = source.slice(delimiterIndex + 5);
-  const parsed = parseYaml(yamlSource);
-  return {
-    frontmatter: parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {},
-    body
-  };
-}
-function serializeFrontmatterDocument(frontmatter, body) {
-  return `---
-${stringifyYaml(frontmatter).trimEnd()}
----
-${body.replace(/^\n*/, "")}`;
-}
-export {
-  parseFrontmatterDocument,
-  serializeFrontmatterDocument
-};

package/dist/content-sync/index.d.ts

@@ -1 +0,0 @@
-export * from './reconcile.js';

package/dist/content-sync/index.js

@@ -1 +0,0 @@
-export * from "./reconcile.js";

package/dist/content-sync/reconcile.d.ts

@@ -1,28 +0,0 @@
-export type ContentSyncStatus = 'up-to-date' | 'fast-forward' | 'verification-required' | 'blocked';
-export interface ContentSyncPlan {
-    repositoryRoot: string;
-    branch: string;
-    localHead: string;
-    upstreamHead: string | null;
-    treeDxHead: string | null;
-    publishedHead: string | null;
-    publicationRevision: string | null;
-    remoteUrl: string | null;
-    canonicalRemoteUrl: string | null;
-    providerHead: string | null;
-    dirtyPaths: string[];
-    status: ContentSyncStatus;
-    blockers: string[];
-}
-export interface ContentSyncInput {
-    repositoryRoot: string;
-    branch: string;
-    treeDxHead: string | null;
-    publishedHead: string | null;
-    publicationRevision: string | null;
-    canonicalRemoteUrl?: string | null;
-    providerHead?: string | null;
-    env?: NodeJS.ProcessEnv | Record<string, string | undefined>;
-}
-export declare function planContentSync(input: ContentSyncInput): ContentSyncPlan;
-export declare function applyContentSync(expected: ContentSyncPlan, env?: ContentSyncInput['env']): ContentSyncPlan;

package/dist/content-sync/reconcile.js

@@ -1,125 +0,0 @@
-import { runRepositoryGit } from "../operations/services/operations/git-runner.js";
-function output(root, args, env) {
-  return runRepositoryGit(args, { cwd: root, mode: "read", env }).stdout.trim();
-}
-function remoteHead(root, branch, env) {
-  const result = runRepositoryGit(["ls-remote", "--heads", "origin", `refs/heads/${branch}`], {
-    cwd: root,
-    mode: "read",
-    allowFailure: true,
-    env
-  });
-  if (result.status !== 0) return null;
-  return result.stdout.trim().split(/\s+/u)[0] || null;
-}
-function isAncestor(root, ancestor, descendant) {
-  return runRepositoryGit(["merge-base", "--is-ancestor", ancestor, descendant], {
-    cwd: root,
-    mode: "read",
-    allowFailure: true
-  }).status === 0;
-}
-function hasCommit(root, commit) {
-  return runRepositoryGit(["cat-file", "-e", `${commit}^{commit}`], {
-    cwd: root,
-    mode: "read",
-    allowFailure: true
-  }).status === 0;
-}
-function normalizedRemote(value) {
-  return value?.trim().replace(/\.git$/u, "").replace(/\/$/u, "").toLowerCase() ?? null;
-}
-function planContentSync(input) {
-  const repositoryRoot = output(input.repositoryRoot, ["rev-parse", "--show-toplevel"], input.env);
-  const branch = output(repositoryRoot, ["rev-parse", "--abbrev-ref", "HEAD"], input.env);
-  const localHead = output(repositoryRoot, ["rev-parse", "HEAD"], input.env);
-  const dirtyPaths = output(repositoryRoot, ["status", "--porcelain=v1"], input.env).split(/\r?\n/u).filter(Boolean).map((line) => line.slice(3));
-  const remoteUrl = runRepositoryGit(["remote", "get-url", "origin"], {
-    cwd: repositoryRoot,
-    mode: "read",
-    allowFailure: true,
-    env: input.env
-  }).stdout.trim() || null;
-  const upstreamHead = remoteUrl ? remoteHead(repositoryRoot, input.branch, input.env) : null;
-  const blockers = [];
-  if (branch === "HEAD") blockers.push("The local checkout is detached.");
-  if (branch !== input.branch) blockers.push(`The local branch is ${branch}; expected ${input.branch}.`);
-  if (dirtyPaths.length) blockers.push("The local checkout has uncommitted changes. Save them before content sync.");
-  if (!remoteUrl) blockers.push("The repository has no origin remote.");
-  if (input.canonicalRemoteUrl && normalizedRemote(remoteUrl) !== normalizedRemote(input.canonicalRemoteUrl)) {
-    blockers.push(`The local origin ${remoteUrl ?? "is unavailable"}; the project binding requires ${input.canonicalRemoteUrl}.`);
-  }
-  if (!upstreamHead) blockers.push(`The origin branch ${input.branch} is unavailable.`);
-  if (!input.providerHead) blockers.push("The repository provider did not resolve the publication ref.");
-  if (upstreamHead && input.providerHead && upstreamHead !== input.providerHead) {
-    blockers.push(`The provider resolves ${input.providerHead}, but origin/${input.branch} resolves ${upstreamHead}. Re-plan after provider reconciliation.`);
-  }
-  if (!input.treeDxHead) blockers.push("TreeDX did not resolve the requested publication ref.");
-  if (!input.publishedHead || !input.publicationRevision) blockers.push("The project is not included in an atomic knowledge publication.");
-  if (upstreamHead && input.treeDxHead && upstreamHead !== input.treeDxHead) {
-    blockers.push(`TreeDX resolves ${input.treeDxHead}, but origin/${input.branch} resolves ${upstreamHead}. Refresh TreeDX before syncing the checkout.`);
-  }
-  if (upstreamHead && input.publishedHead && upstreamHead !== input.publishedHead) {
-    blockers.push(`Published knowledge resolves ${input.publishedHead}, but origin/${input.branch} resolves ${upstreamHead}. Publish the exact source closure before syncing the checkout.`);
-  }
-  const upstreamCommitAvailable = Boolean(upstreamHead && hasCommit(repositoryRoot, upstreamHead));
-  const remoteCanFastForward = !upstreamHead || localHead === upstreamHead || upstreamCommitAvailable && isAncestor(repositoryRoot, localHead, upstreamHead);
-  if (upstreamHead && localHead !== upstreamHead && upstreamCommitAvailable && !remoteCanFastForward) {
-    blockers.push("The local checkout and publication ref have diverged; fast-forward sync is unsafe.");
-  }
-  const needsVerification = Boolean(upstreamHead && localHead !== upstreamHead && !upstreamCommitAvailable);
-  return {
-    repositoryRoot,
-    branch,
-    localHead,
-    upstreamHead,
-    treeDxHead: input.treeDxHead,
-    publishedHead: input.publishedHead,
-    publicationRevision: input.publicationRevision,
-    remoteUrl,
-    canonicalRemoteUrl: input.canonicalRemoteUrl ?? null,
-    providerHead: input.providerHead ?? null,
-    dirtyPaths,
-    status: blockers.length ? "blocked" : localHead === upstreamHead ? "up-to-date" : needsVerification ? "verification-required" : "fast-forward",
-    blockers
-  };
-}
-function applyContentSync(expected, env) {
-  const current = planContentSync({
-    repositoryRoot: expected.repositoryRoot,
-    branch: expected.branch,
-    treeDxHead: expected.treeDxHead,
-    publishedHead: expected.publishedHead,
-    publicationRevision: expected.publicationRevision,
-    canonicalRemoteUrl: expected.canonicalRemoteUrl,
-    providerHead: expected.providerHead,
-    env
-  });
-  if (current.blockers.length) throw new Error(`Content sync is blocked:
-- ${current.blockers.join("\n- ")}`);
-  if (current.localHead !== expected.localHead || current.upstreamHead !== expected.upstreamHead) {
-    throw new Error("Content sync state changed after planning. Run the plan again.");
-  }
-  if (current.status === "up-to-date") return current;
-  runRepositoryGit(["fetch", "origin", current.branch], { cwd: current.repositoryRoot, mode: "mutate", env });
-  const fetchedHead = output(current.repositoryRoot, ["rev-parse", `origin/${current.branch}`], env);
-  if (fetchedHead !== current.upstreamHead) throw new Error("The upstream ref changed during content sync. Run the plan again.");
-  if (!isAncestor(current.repositoryRoot, current.localHead, fetchedHead)) {
-    throw new Error("The local checkout and publication ref have diverged; fast-forward sync is unsafe.");
-  }
-  runRepositoryGit(["merge", "--ff-only", `origin/${current.branch}`], { cwd: current.repositoryRoot, mode: "mutate", env });
-  return planContentSync({
-    repositoryRoot: current.repositoryRoot,
-    branch: current.branch,
-    treeDxHead: current.treeDxHead,
-    publishedHead: current.publishedHead,
-    publicationRevision: current.publicationRevision,
-    canonicalRemoteUrl: current.canonicalRemoteUrl,
-    providerHead: current.providerHead,
-    env
-  });
-}
-export {
-  applyContentSync,
-  planContentSync
-};

package/dist/d1-store/content/try-claim-content-lease.d.ts

@@ -1,2 +0,0 @@
-import { MemoryAgentDatabase, TryClaimContentLeaseInput } from "../../persistence/d1-store.js";
-export declare function tryClaimContentLeaseMethod(this: MemoryAgentDatabase, input: TryClaimContentLeaseInput): Promise<`${string}-${string}-${string}-${string}-${string}` | null>;

package/dist/d1-store/content/try-claim-content-lease.js

@@ -1,21 +0,0 @@
-import { nextLeaseToken, nowIso } from "../../persistence/d1-store.js";
-async function tryClaimContentLeaseMethod(input) {
-  const key = `${input.model}:${input.itemKey}`;
-  const existing = this.contentLeases.get(key);
-  if (existing && new Date(existing.leaseExpiresAt).valueOf() > Date.now()) {
-    return null;
-  }
-  const token = nextLeaseToken();
-  this.contentLeases.set(key, {
-    model: input.model,
-    itemKey: input.itemKey,
-    claimedBy: input.claimedBy,
-    claimedAt: nowIso(),
-    leaseExpiresAt: new Date(Date.now() + input.leaseSeconds * 1e3).toISOString(),
-    token
-  });
-  return token;
-}
-export {
-  tryClaimContentLeaseMethod
-};

package/dist/d1-store/methods.d.ts

@@ -1,32 +0,0 @@
-export { tryClaimContentLeaseMethod } from './content/try-claim-content-lease.js';
-export { getReleaseMethod } from './packages/get-release.js';
-export { getSharePackageMethod } from './packages/get-share-package.js';
-export { listReleasesMethod } from './packages/list-releases.js';
-export { listSharePackagesMethod } from './packages/list-share-packages.js';
-export { releaseAllLeasesMethod } from './packages/release-all-leases.js';
-export { releaseLeaseMethod } from './packages/release-lease.js';
-export { upsertReleaseMethod } from './packages/upsert-release.js';
-export { upsertSharePackageMethod } from './packages/upsert-share-package.js';
-export { createApprovalRequestMethod } from './support/approvals/create-approval-request.js';
-export { decideApprovalRequestMethod } from './support/approvals/decide-approval-request.js';
-export { listApprovalRequestsMethod } from './support/approvals/list-approval-requests.js';
-export { getCursorMethod } from './support/cursors/get-cursor.js';
-export { upsertCursorMethod } from './support/cursors/upsert-cursor.js';
-export { inspectLeasesMethod } from './support/execution/inspect-leases.js';
-export { inspectRunsMethod } from './support/execution/inspect-runs.js';
-export { ackMessageMethod } from './support/messages/ack-message.js';
-export { claimMessageMethod } from './support/messages/claim-message.js';
-export { createMessageMethod } from './support/messages/create-message.js';
-export { followMethod } from './support/queries/follow.js';
-export { pickMethod } from './support/queries/pick.js';
-export { searchMethod } from './support/queries/search.js';
-export { createMethod } from './support/records/create-record.js';
-export { getMethod } from './support/records/get-record.js';
-export { recordRunMethod } from './support/records/record-run.js';
-export { rowsForModelMethod } from './support/records/rows-for-model.js';
-export { updateMethod } from './support/update.js';
-export { appendWorkstreamEventMethod } from './support/workstreams/append-workstream-event.js';
-export { getWorkstreamMethod } from './support/workstreams/get-workstream.js';
-export { listWorkstreamsMethod } from './support/workstreams/list-workstreams.js';
-export { upsertWorkstreamMethod } from './support/workstreams/upsert-workstream.js';
-export { upsertTeamInboxItemMethod } from './teams/upsert-team-inbox-item.js';

package/dist/d1-store/methods.js

@@ -1,66 +0,0 @@
-import { tryClaimContentLeaseMethod } from "./content/try-claim-content-lease.js";
-import { getReleaseMethod } from "./packages/get-release.js";
-import { getSharePackageMethod } from "./packages/get-share-package.js";
-import { listReleasesMethod } from "./packages/list-releases.js";
-import { listSharePackagesMethod } from "./packages/list-share-packages.js";
-import { releaseAllLeasesMethod } from "./packages/release-all-leases.js";
-import { releaseLeaseMethod } from "./packages/release-lease.js";
-import { upsertReleaseMethod } from "./packages/upsert-release.js";
-import { upsertSharePackageMethod } from "./packages/upsert-share-package.js";
-import { createApprovalRequestMethod } from "./support/approvals/create-approval-request.js";
-import { decideApprovalRequestMethod } from "./support/approvals/decide-approval-request.js";
-import { listApprovalRequestsMethod } from "./support/approvals/list-approval-requests.js";
-import { getCursorMethod } from "./support/cursors/get-cursor.js";
-import { upsertCursorMethod } from "./support/cursors/upsert-cursor.js";
-import { inspectLeasesMethod } from "./support/execution/inspect-leases.js";
-import { inspectRunsMethod } from "./support/execution/inspect-runs.js";
-import { ackMessageMethod } from "./support/messages/ack-message.js";
-import { claimMessageMethod } from "./support/messages/claim-message.js";
-import { createMessageMethod } from "./support/messages/create-message.js";
-import { followMethod } from "./support/queries/follow.js";
-import { pickMethod } from "./support/queries/pick.js";
-import { searchMethod } from "./support/queries/search.js";
-import { createMethod } from "./support/records/create-record.js";
-import { getMethod } from "./support/records/get-record.js";
-import { recordRunMethod } from "./support/records/record-run.js";
-import { rowsForModelMethod } from "./support/records/rows-for-model.js";
-import { updateMethod } from "./support/update.js";
-import { appendWorkstreamEventMethod } from "./support/workstreams/append-workstream-event.js";
-import { getWorkstreamMethod } from "./support/workstreams/get-workstream.js";
-import { listWorkstreamsMethod } from "./support/workstreams/list-workstreams.js";
-import { upsertWorkstreamMethod } from "./support/workstreams/upsert-workstream.js";
-import { upsertTeamInboxItemMethod } from "./teams/upsert-team-inbox-item.js";
-export {
-  ackMessageMethod,
-  appendWorkstreamEventMethod,
-  claimMessageMethod,
-  createApprovalRequestMethod,
-  createMessageMethod,
-  createMethod,
-  decideApprovalRequestMethod,
-  followMethod,
-  getCursorMethod,
-  getMethod,
-  getReleaseMethod,
-  getSharePackageMethod,
-  getWorkstreamMethod,
-  inspectLeasesMethod,
-  inspectRunsMethod,
-  listApprovalRequestsMethod,
-  listReleasesMethod,
-  listSharePackagesMethod,
-  listWorkstreamsMethod,
-  pickMethod,
-  recordRunMethod,
-  releaseAllLeasesMethod,
-  releaseLeaseMethod,
-  rowsForModelMethod,
-  searchMethod,
-  tryClaimContentLeaseMethod,
-  updateMethod,
-  upsertCursorMethod,
-  upsertReleaseMethod,
-  upsertSharePackageMethod,
-  upsertTeamInboxItemMethod,
-  upsertWorkstreamMethod
-};

package/dist/d1-store/packages/get-release.d.ts

@@ -1,2 +0,0 @@
-import { MemoryAgentDatabase } from "../../persistence/d1-store.js";
-export declare function getReleaseMethod(this: MemoryAgentDatabase, releaseId: string): Promise<import("../../index.js").ReleaseDetail | null>;

package/dist/d1-store/packages/get-release.js

@@ -1,6 +0,0 @@
-function getReleaseMethod(releaseId) {
-  return Promise.resolve(this.projectWorkflow.getRelease(releaseId));
-}
-export {
-  getReleaseMethod
-};

package/dist/d1-store/packages/get-share-package.d.ts

@@ -1,2 +0,0 @@
-import { MemoryAgentDatabase } from "../../persistence/d1-store.js";
-export declare function getSharePackageMethod(this: MemoryAgentDatabase, packageId: string): Promise<import("../../index.js").SharePackageStatus | null>;

package/dist/d1-store/packages/get-share-package.js

@@ -1,6 +0,0 @@
-function getSharePackageMethod(packageId) {
-  return Promise.resolve(this.projectWorkflow.getSharePackage(packageId));
-}
-export {
-  getSharePackageMethod
-};

package/dist/d1-store/packages/list-releases.d.ts

@@ -1,2 +0,0 @@
-import { MemoryAgentDatabase } from "../../persistence/d1-store.js";
-export declare function listReleasesMethod(this: MemoryAgentDatabase, projectId: string): Promise<import("../../index.js").ReleaseSummary[]>;

package/dist/d1-store/packages/list-releases.js

@@ -1,6 +0,0 @@
-function listReleasesMethod(projectId) {
-  return Promise.resolve(this.projectWorkflow.listReleases(projectId));
-}
-export {
-  listReleasesMethod
-};

package/dist/d1-store/packages/list-share-packages.d.ts

@@ -1,2 +0,0 @@
-import { MemoryAgentDatabase } from "../../persistence/d1-store.js";
-export declare function listSharePackagesMethod(this: MemoryAgentDatabase, projectId: string): Promise<import("../../index.js").SharePackageStatus[]>;

package/dist/d1-store/packages/list-share-packages.js

@@ -1,6 +0,0 @@
-function listSharePackagesMethod(projectId) {
-  return Promise.resolve(this.projectWorkflow.listSharePackages(projectId));
-}
-export {
-  listSharePackagesMethod
-};

package/dist/d1-store/packages/release-all-leases.d.ts

@@ -1,2 +0,0 @@
-import { MemoryAgentDatabase } from "../../persistence/d1-store.js";
-export declare function releaseAllLeasesMethod(this: MemoryAgentDatabase): Promise<number>;

package/dist/d1-store/packages/release-all-leases.js

@@ -1,8 +0,0 @@
-async function releaseAllLeasesMethod() {
-  const count = this.contentLeases.size;
-  this.contentLeases.clear();
-  return count;
-}
-export {
-  releaseAllLeasesMethod
-};