@treeseed/sdk 0.1.1

package/dist/model-registry.js

@@ -0,0 +1,164 @@
+import path from "node:path";
+import { resolveSdkRepoRoot } from "./runtime.js";
+function contentRoot() {
+  return process.env.TREESEED_AGENT_CONTENT_ROOT ? path.resolve(process.env.TREESEED_AGENT_CONTENT_ROOT) : path.resolve(resolveSdkRepoRoot(), "src", "content");
+}
+function buildModelRegistry() {
+  const root = contentRoot();
+  return {
+    page: {
+      name: "page",
+      aliases: ["pages"],
+      storage: "content",
+      operations: ["get", "read", "search", "follow", "pick", "create", "update"],
+      filterableFields: ["title", "slug", "status", "audience", "updated"],
+      sortableFields: ["title", "updated"],
+      pickField: "updated",
+      contentCollection: "pages",
+      contentDir: path.join(root, "pages")
+    },
+    note: {
+      name: "note",
+      aliases: ["notes"],
+      storage: "content",
+      operations: ["get", "read", "search", "follow", "pick", "create", "update"],
+      filterableFields: ["title", "status", "author", "tags", "date", "updated"],
+      sortableFields: ["title", "date", "updated"],
+      pickField: "date",
+      contentCollection: "notes",
+      contentDir: path.join(root, "notes")
+    },
+    question: {
+      name: "question",
+      aliases: ["questions"],
+      storage: "content",
+      operations: ["get", "read", "search", "follow", "pick", "create", "update"],
+      filterableFields: ["title", "status", "tags", "date", "questionType", "relatedObjectives", "relatedBooks"],
+      sortableFields: ["title", "date", "updated"],
+      pickField: "date",
+      contentCollection: "questions",
+      contentDir: path.join(root, "questions")
+    },
+    book: {
+      name: "book",
+      aliases: ["books"],
+      storage: "content",
+      operations: ["get", "read", "search", "follow", "pick", "create", "update"],
+      filterableFields: ["title", "slug", "tags", "sectionLabel"],
+      sortableFields: ["title", "order", "updated"],
+      pickField: "order",
+      contentCollection: "books",
+      contentDir: path.join(root, "books")
+    },
+    knowledge: {
+      name: "knowledge",
+      aliases: ["knowledge-base", "docs"],
+      storage: "content",
+      operations: ["get", "read", "search", "follow", "pick", "create", "update"],
+      filterableFields: ["title", "tags", "updated", "slug"],
+      sortableFields: ["title", "updated"],
+      pickField: "updated",
+      contentCollection: "docs",
+      contentDir: path.join(root, "knowledge")
+    },
+    objective: {
+      name: "objective",
+      aliases: ["objectives"],
+      storage: "content",
+      operations: ["get", "read", "search", "follow", "pick", "create", "update"],
+      filterableFields: ["title", "status", "tags", "date", "timeHorizon", "relatedQuestions", "relatedBooks"],
+      sortableFields: ["title", "date", "updated"],
+      pickField: "date",
+      contentCollection: "objectives",
+      contentDir: path.join(root, "objectives")
+    },
+    person: {
+      name: "person",
+      aliases: ["people", "persons"],
+      storage: "content",
+      operations: ["get", "read", "search", "follow", "pick", "create", "update"],
+      filterableFields: ["name", "role", "affiliation", "status", "tags"],
+      sortableFields: ["name", "updated"],
+      pickField: "updated",
+      contentCollection: "people",
+      contentDir: path.join(root, "people")
+    },
+    subscription: {
+      name: "subscription",
+      aliases: ["subscriptions", "subscriber", "subscribers"],
+      storage: "d1",
+      operations: ["get", "read", "search", "follow", "pick", "create", "update"],
+      filterableFields: ["email", "status", "source", "created_at", "updated_at"],
+      sortableFields: ["email", "created_at", "updated_at"],
+      pickField: "updated_at"
+    },
+    message: {
+      name: "message",
+      aliases: ["messages"],
+      storage: "d1",
+      operations: ["get", "read", "search", "follow", "pick", "create", "update"],
+      filterableFields: ["type", "status", "related_model", "related_id", "priority", "available_at"],
+      sortableFields: ["priority", "available_at", "created_at", "updated_at"],
+      pickField: "available_at"
+    },
+    agent: {
+      name: "agent",
+      aliases: ["agents"],
+      storage: "content",
+      operations: ["get", "read", "search", "follow", "pick", "create", "update"],
+      filterableFields: ["slug", "runtimeStatus", "tags", "operator"],
+      sortableFields: ["name", "slug", "updated"],
+      pickField: "updated",
+      contentCollection: "agents",
+      contentDir: path.join(root, "agents")
+    },
+    agent_run: {
+      name: "agent_run",
+      aliases: ["agent_runs", "run", "runs"],
+      storage: "d1",
+      operations: ["get", "read", "search", "follow", "create", "update"],
+      filterableFields: ["run_id", "agent_slug", "status", "started_at", "finished_at"],
+      sortableFields: ["started_at", "finished_at"],
+      pickField: "started_at"
+    },
+    agent_cursor: {
+      name: "agent_cursor",
+      aliases: ["agent_cursors", "cursor", "cursors"],
+      storage: "d1",
+      operations: ["get", "read", "search", "follow", "create", "update"],
+      filterableFields: ["agent_slug", "cursor_key", "cursor_value", "updated_at"],
+      sortableFields: ["updated_at", "agent_slug", "cursor_key"],
+      pickField: "updated_at"
+    },
+    content_lease: {
+      name: "content_lease",
+      aliases: ["content_leases", "lease", "leases"],
+      storage: "d1",
+      operations: ["get", "read", "search", "follow", "create", "update"],
+      filterableFields: ["model", "item_key", "claimed_by", "lease_expires_at"],
+      sortableFields: ["lease_expires_at", "claimed_at"],
+      pickField: "lease_expires_at"
+    }
+  };
+}
+const MODEL_REGISTRY = buildModelRegistry();
+function resolveModelDefinition(model) {
+  const registry = buildModelRegistry();
+  const directMatch = registry[model];
+  if (directMatch) {
+    return directMatch;
+  }
+  const normalized = model.trim().toLowerCase();
+  const aliasMatch = Object.values(registry).find(
+    (definition) => definition.aliases.includes(normalized) || definition.name === normalized
+  );
+  if (!aliasMatch) {
+    throw new Error(`Unknown SDK model "${model}".`);
+  }
+  return aliasMatch;
+}
+export {
+  MODEL_REGISTRY,
+  buildModelRegistry,
+  resolveModelDefinition
+};

package/dist/runtime.js

@@ -0,0 +1,36 @@
+import { existsSync } from "node:fs";
+import path from "node:path";
+function findContentRoot(start) {
+  let current = path.resolve(start);
+  for (; ; ) {
+    if (existsSync(path.join(current, "fixture", "src", "content"))) {
+      return path.join(current, "fixture");
+    }
+    if (existsSync(path.join(current, "src", "content"))) {
+      return current;
+    }
+    if (existsSync(path.join(current, "docs", "src", "content"))) {
+      return path.join(current, "docs");
+    }
+    const parent = path.dirname(current);
+    if (parent === current) {
+      return null;
+    }
+    current = parent;
+  }
+}
+function resolveSdkRepoRoot(repoRoot) {
+  if (repoRoot) {
+    return path.resolve(repoRoot);
+  }
+  if (process.env.TREESEED_SDK_CONTENT_ROOT) {
+    return path.resolve(process.env.TREESEED_SDK_CONTENT_ROOT);
+  }
+  if (process.env.TREESEED_SDK_REPO_ROOT) {
+    return path.resolve(process.env.TREESEED_SDK_REPO_ROOT);
+  }
+  return findContentRoot(process.cwd()) ?? process.cwd();
+}
+export {
+  resolveSdkRepoRoot
+};

package/dist/scripts/.ts-run-1775616845195-odh4xzphk3l.js

@@ -0,0 +1,22 @@
+// scripts/publish-package.ts
+import { spawnSync } from "node:child_process";
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+var packageRoot = resolve(fileURLToPath(new URL("..", import.meta.url)));
+var extraArgs = process.argv.slice(2);
+var npmArgs = ["publish", ".", "--access", "public"];
+if (process.env.GITHUB_ACTIONS === "true") {
+  npmArgs.push("--provenance");
+}
+npmArgs.push(...extraArgs);
+var result = spawnSync("npm", npmArgs, {
+  cwd: packageRoot,
+  stdio: "inherit",
+  env: process.env
+});
+if (result.error) {
+  console.error(result.error.message);
+  process.exit(1);
+}
+process.exit(result.status ?? 1);
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsicHVibGlzaC1wYWNrYWdlLnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyJpbXBvcnQgeyBzcGF3blN5bmMgfSBmcm9tICdub2RlOmNoaWxkX3Byb2Nlc3MnO1xuaW1wb3J0IHsgcmVzb2x2ZSB9IGZyb20gJ25vZGU6cGF0aCc7XG5pbXBvcnQgeyBmaWxlVVJMVG9QYXRoIH0gZnJvbSAnbm9kZTp1cmwnO1xuXG5jb25zdCBwYWNrYWdlUm9vdCA9IHJlc29sdmUoZmlsZVVSTFRvUGF0aChuZXcgVVJMKCcuLicsIGltcG9ydC5tZXRhLnVybCkpKTtcbmNvbnN0IGV4dHJhQXJncyA9IHByb2Nlc3MuYXJndi5zbGljZSgyKTtcblxuY29uc3QgbnBtQXJncyA9IFsncHVibGlzaCcsICcuJywgJy0tYWNjZXNzJywgJ3B1YmxpYyddO1xuXG5pZiAocHJvY2Vzcy5lbnYuR0lUSFVCX0FDVElPTlMgPT09ICd0cnVlJykge1xuXHRucG1BcmdzLnB1c2goJy0tcHJvdmVuYW5jZScpO1xufVxuXG5ucG1BcmdzLnB1c2goLi4uZXh0cmFBcmdzKTtcblxuY29uc3QgcmVzdWx0ID0gc3Bhd25TeW5jKCducG0nLCBucG1BcmdzLCB7XG5cdGN3ZDogcGFja2FnZVJvb3QsXG5cdHN0ZGlvOiAnaW5oZXJpdCcsXG5cdGVudjogcHJvY2Vzcy5lbnYsXG59KTtcblxuaWYgKHJlc3VsdC5lcnJvcikge1xuXHRjb25zb2xlLmVycm9yKHJlc3VsdC5lcnJvci5tZXNzYWdlKTtcblx0cHJvY2Vzcy5leGl0KDEpO1xufVxuXG5wcm9jZXNzLmV4aXQocmVzdWx0LnN0YXR1cyA/PyAxKTtcbiJdLAogICJtYXBwaW5ncyI6ICI7QUFBQSxTQUFTLGlCQUFpQjtBQUMxQixTQUFTLGVBQWU7QUFDeEIsU0FBUyxxQkFBcUI7QUFFOUIsSUFBTSxjQUFjLFFBQVEsY0FBYyxJQUFJLElBQUksTUFBTSxZQUFZLEdBQUcsQ0FBQyxDQUFDO0FBQ3pFLElBQU0sWUFBWSxRQUFRLEtBQUssTUFBTSxDQUFDO0FBRXRDLElBQU0sVUFBVSxDQUFDLFdBQVcsS0FBSyxZQUFZLFFBQVE7QUFFckQsSUFBSSxRQUFRLElBQUksbUJBQW1CLFFBQVE7QUFDMUMsVUFBUSxLQUFLLGNBQWM7QUFDNUI7QUFFQSxRQUFRLEtBQUssR0FBRyxTQUFTO0FBRXpCLElBQU0sU0FBUyxVQUFVLE9BQU8sU0FBUztBQUFBLEVBQ3hDLEtBQUs7QUFBQSxFQUNMLE9BQU87QUFBQSxFQUNQLEtBQUssUUFBUTtBQUNkLENBQUM7QUFFRCxJQUFJLE9BQU8sT0FBTztBQUNqQixVQUFRLE1BQU0sT0FBTyxNQUFNLE9BQU87QUFDbEMsVUFBUSxLQUFLLENBQUM7QUFDZjtBQUVBLFFBQVEsS0FBSyxPQUFPLFVBQVUsQ0FBQzsiLAogICJuYW1lcyI6IFtdCn0K

package/dist/scripts/.ts-run-1775616848931-9386s6kwrl.js

@@ -0,0 +1,126 @@
+// scripts/build-dist.ts
+import { copyFileSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { dirname as dirname2, extname as extname2, join, relative, resolve as resolve2 } from "node:path";
+import { build } from "esbuild";
+import ts from "typescript";
+
+// scripts/package-tools.ts
+import { dirname, extname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { createRequire } from "node:module";
+var require2 = createRequire(import.meta.url);
+var scriptRoot = dirname(fileURLToPath(import.meta.url));
+var packageCandidate = resolve(scriptRoot, "..");
+var packageRoot = packageCandidate.endsWith("/dist") ? resolve(packageCandidate, "..") : packageCandidate;
+var packageScriptRoot = packageCandidate.endsWith("/dist") ? resolve(packageCandidate, "scripts") : resolve(packageRoot, "scripts");
+
+// scripts/build-dist.ts
+var srcRoot = resolve2(packageRoot, "src");
+var scriptsRoot = resolve2(packageRoot, "scripts");
+var distRoot = resolve2(packageRoot, "dist");
+var COPY_EXTENSIONS = /* @__PURE__ */ new Set([".d.js", ".json", ".md"]);
+function walkFiles(root) {
+  const files = [];
+  for (const entry of readdirSync(root, { withFileTypes: true })) {
+    const fullPath = join(root, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...walkFiles(fullPath));
+      continue;
+    }
+    files.push(fullPath);
+  }
+  return files;
+}
+function ensureDir(filePath) {
+  mkdirSync(dirname2(filePath), { recursive: true });
+}
+function rewriteRuntimeSpecifiers(contents) {
+  return contents.replace(/(['"`])(\.[^'"`\n]+)\.(mjs|ts)\1/g, "$1$2.js$1");
+}
+async function compileModule(filePath, sourceRoot, outputRoot) {
+  const relativePath = relative(sourceRoot, filePath);
+  const outputFile = resolve2(outputRoot, relativePath.replace(/\.(mjs|ts)$/u, ".js"));
+  ensureDir(outputFile);
+  await build({
+    entryPoints: [filePath],
+    outfile: outputFile,
+    platform: "node",
+    format: "esm",
+    bundle: false,
+    logLevel: "silent"
+  });
+  const builtSource = readFileSync(outputFile, "utf8");
+  writeFileSync(outputFile, rewriteRuntimeSpecifiers(builtSource), "utf8");
+}
+function copyAsset(filePath, sourceRoot, outputRoot) {
+  const outputFile = resolve2(outputRoot, relative(sourceRoot, filePath));
+  ensureDir(outputFile);
+  copyFileSync(filePath, outputFile);
+  if (outputFile.endsWith(".d.js")) {
+    const contents = readFileSync(outputFile, "utf8");
+    writeFileSync(outputFile, rewriteRuntimeSpecifiers(contents), "utf8");
+  }
+}
+function transpileScript(filePath) {
+  const source = readFileSync(filePath, "utf8");
+  const relativePath = relative(scriptsRoot, filePath);
+  const outputFile = resolve2(distRoot, "scripts", relativePath.replace(/\.(mjs|ts)$/u, ".js"));
+  const transformed = extname2(filePath) === ".ts" ? ts.transpileModule(source, {
+    compilerOptions: {
+      module: ts.ModuleKind.ESNext,
+      target: ts.ScriptTarget.ES2022
+    }
+  }).outputText : source;
+  ensureDir(outputFile);
+  writeFileSync(outputFile, rewriteRuntimeSpecifiers(transformed), "utf8");
+}
+function emitDeclarations() {
+  const configPath = ts.findConfigFile(packageRoot, ts.sys.fileExists, "tsconfig.json");
+  if (!configPath) {
+    throw new Error("Unable to locate tsconfig.json for declaration build.");
+  }
+  const configFile = ts.readConfigFile(configPath, ts.sys.readFile);
+  const parsed = ts.parseJsonConfigFileContent(configFile.config, ts.sys, packageRoot);
+  const program = ts.createProgram({
+    rootNames: parsed.fileNames,
+    options: {
+      ...parsed.options,
+      declaration: true,
+      emitDeclarationOnly: true,
+      declarationDir: distRoot,
+      noEmit: false
+    }
+  });
+  const result = program.emit();
+  if (result.emitSkipped) {
+    const diagnostics = ts.formatDiagnosticsWithColorAndContext(result.diagnostics, {
+      getCanonicalFileName: (fileName) => fileName,
+      getCurrentDirectory: () => process.cwd(),
+      getNewLine: () => "\n"
+    });
+    throw new Error(`Declaration build failed.
+${diagnostics}`);
+  }
+}
+rmSync(distRoot, { recursive: true, force: true });
+for (const filePath of walkFiles(srcRoot)) {
+  const extension = extname2(filePath);
+  if (extension === ".ts") {
+    await compileModule(filePath, srcRoot, distRoot);
+    continue;
+  }
+  if (COPY_EXTENSIONS.has(extension)) {
+    copyAsset(filePath, srcRoot, distRoot);
+  }
+}
+for (const filePath of walkFiles(scriptsRoot)) {
+  const extension = extname2(filePath);
+  if (extension === ".ts" || extension === ".mjs") {
+    transpileScript(filePath);
+  }
+}
+emitDeclarations();
+if (existsSync(resolve2(packageRoot, "README.md"))) {
+  copyFileSync(resolve2(packageRoot, "README.md"), resolve2(distRoot, "..", "README.md"));
+}
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["build-dist.ts", "package-tools.ts"],
  "sourcesContent": ["import { copyFileSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';\nimport { dirname, extname, join, relative, resolve } from 'node:path';\nimport { build } from 'esbuild';\nimport ts from 'typescript';\nimport { packageRoot } from './package-tools.ts';\n\nconst srcRoot = resolve(packageRoot, 'src');\nconst scriptsRoot = resolve(packageRoot, 'scripts');\nconst distRoot = resolve(packageRoot, 'dist');\n\nconst COPY_EXTENSIONS = new Set(['.d.ts', '.json', '.md']);\n\nfunction walkFiles(root) {\n\tconst files = [];\n\tfor (const entry of readdirSync(root, { withFileTypes: true })) {\n\t\tconst fullPath = join(root, entry.name);\n\t\tif (entry.isDirectory()) {\n\t\t\tfiles.push(...walkFiles(fullPath));\n\t\t\tcontinue;\n\t\t}\n\t\tfiles.push(fullPath);\n\t}\n\treturn files;\n}\n\nfunction ensureDir(filePath) {\n\tmkdirSync(dirname(filePath), { recursive: true });\n}\n\nfunction rewriteRuntimeSpecifiers(contents) {\n\treturn contents.replace(/(['\"`])(\\.[^'\"`\\n]+)\\.(mjs|ts)\\1/g, '$1$2.js$1');\n}\n\nasync function compileModule(filePath, sourceRoot, outputRoot) {\n\tconst relativePath = relative(sourceRoot, filePath);\n\tconst outputFile = resolve(outputRoot, relativePath.replace(/\\.(mjs|ts)$/u, '.js'));\n\tensureDir(outputFile);\n\n\tawait build({\n\t\tentryPoints: [filePath],\n\t\toutfile: outputFile,\n\t\tplatform: 'node',\n\t\tformat: 'esm',\n\t\tbundle: false,\n\t\tlogLevel: 'silent',\n\t});\n\n\tconst builtSource = readFileSync(outputFile, 'utf8');\n\twriteFileSync(outputFile, rewriteRuntimeSpecifiers(builtSource), 'utf8');\n}\n\nfunction copyAsset(filePath, sourceRoot, outputRoot) {\n\tconst outputFile = resolve(outputRoot, relative(sourceRoot, filePath));\n\tensureDir(outputFile);\n\tcopyFileSync(filePath, outputFile);\n\n\tif (outputFile.endsWith('.d.ts')) {\n\t\tconst contents = readFileSync(outputFile, 'utf8');\n\t\twriteFileSync(outputFile, rewriteRuntimeSpecifiers(contents), 'utf8');\n\t}\n}\n\nfunction transpileScript(filePath) {\n\tconst source = readFileSync(filePath, 'utf8');\n\tconst relativePath = relative(scriptsRoot, filePath);\n\tconst outputFile = resolve(distRoot, 'scripts', relativePath.replace(/\\.(mjs|ts)$/u, '.js'));\n\tconst transformed = extname(filePath) === '.ts'\n\t\t? ts.transpileModule(source, {\n\t\t\t\tcompilerOptions: {\n\t\t\t\t\tmodule: ts.ModuleKind.ESNext,\n\t\t\t\t\ttarget: ts.ScriptTarget.ES2022,\n\t\t\t\t},\n\t\t\t}).outputText\n\t\t: source;\n\n\tensureDir(outputFile);\n\twriteFileSync(outputFile, rewriteRuntimeSpecifiers(transformed), 'utf8');\n}\n\nfunction emitDeclarations() {\n\tconst configPath = ts.findConfigFile(packageRoot, ts.sys.fileExists, 'tsconfig.json');\n\tif (!configPath) {\n\t\tthrow new Error('Unable to locate tsconfig.json for declaration build.');\n\t}\n\n\tconst configFile = ts.readConfigFile(configPath, ts.sys.readFile);\n\tconst parsed = ts.parseJsonConfigFileContent(configFile.config, ts.sys, packageRoot);\n\tconst program = ts.createProgram({\n\t\trootNames: parsed.fileNames,\n\t\toptions: {\n\t\t\t...parsed.options,\n\t\t\tdeclaration: true,\n\t\t\temitDeclarationOnly: true,\n\t\t\tdeclarationDir: distRoot,\n\t\t\tnoEmit: false,\n\t\t},\n\t});\n\n\tconst result = program.emit();\n\tif (result.emitSkipped) {\n\t\tconst diagnostics = ts.formatDiagnosticsWithColorAndContext(result.diagnostics, {\n\t\t\tgetCanonicalFileName: (fileName) => fileName,\n\t\t\tgetCurrentDirectory: () => process.cwd(),\n\t\t\tgetNewLine: () => '\\n',\n\t\t});\n\t\tthrow new Error(`Declaration build failed.\\n${diagnostics}`);\n\t}\n}\n\nrmSync(distRoot, { recursive: true, force: true });\n\nfor (const filePath of walkFiles(srcRoot)) {\n\tconst extension = extname(filePath);\n\tif (extension === '.ts') {\n\t\tawait compileModule(filePath, srcRoot, distRoot);\n\t\tcontinue;\n\t}\n\n\tif (COPY_EXTENSIONS.has(extension)) {\n\t\tcopyAsset(filePath, srcRoot, distRoot);\n\t}\n}\n\nfor (const filePath of walkFiles(scriptsRoot)) {\n\tconst extension = extname(filePath);\n\tif (extension === '.ts' || extension === '.mjs') {\n\t\ttranspileScript(filePath);\n\t}\n}\n\nemitDeclarations();\n\nif (existsSync(resolve(packageRoot, 'README.md'))) {\n\tcopyFileSync(resolve(packageRoot, 'README.md'), resolve(distRoot, '..', 'README.md'));\n}\n", "import { readFileSync } from 'node:fs';\nimport { existsSync } from 'node:fs';\nimport { dirname, extname, resolve } from 'node:path';\nimport { fileURLToPath } from 'node:url';\nimport { spawn, spawnSync } from 'node:child_process';\nimport { createRequire } from 'node:module';\n\nconst require = createRequire(import.meta.url);\nconst scriptRoot = dirname(fileURLToPath(import.meta.url));\nconst packageCandidate = resolve(scriptRoot, '..');\n\nexport const packageRoot = packageCandidate.endsWith('/dist')\n\t? resolve(packageCandidate, '..')\n\t: packageCandidate;\nexport const packageScriptRoot = packageCandidate.endsWith('/dist')\n\t? resolve(packageCandidate, 'scripts')\n\t: resolve(packageRoot, 'scripts');\n\nfunction resolvePackageBinary(packageName, binName = packageName) {\n\tconst packageJsonPath = require.resolve(`${packageName}/package.json`);\n\tconst packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf8'));\n\tconst binField = packageJson.bin;\n\tconst relativePath =\n\t\ttypeof binField === 'string'\n\t\t\t? binField\n\t\t\t: binField?.[binName];\n\n\tif (!relativePath) {\n\t\tthrow new Error(`Unable to resolve binary \"${binName}\" from package \"${packageName}\".`);\n\t}\n\n\treturn resolve(dirname(packageJsonPath), relativePath);\n}\n\nexport function resolveAstroBin() {\n\treturn resolvePackageBinary('astro', 'astro');\n}\n\nexport function resolveWranglerBin() {\n\treturn resolvePackageBinary('wrangler', 'wrangler');\n}\n\nexport function createProductionBuildEnv(extraEnv = {}) {\n\treturn {\n\t\tTREESEED_LOCAL_DEV_MODE: 'cloudflare',\n\t\tTREESEED_PUBLIC_FORMS_LOCAL_BYPASS_TURNSTILE: '',\n\t\tTREESEED_FORMS_LOCAL_BYPASS_TURNSTILE: '',\n\t\tTREESEED_FORMS_LOCAL_BYPASS_CLOUDFLARE_GUARDS: '',\n\t\tTREESEED_PUBLIC_DEV_WATCH_RELOAD: '',\n\t\t...extraEnv,\n\t};\n}\n\nexport function packageScriptPath(scriptName) {\n\tif (extname(scriptName)) {\n\t\treturn resolve(packageScriptRoot, scriptName);\n\t}\n\n\tfor (const extension of ['.js', '.ts', '.mjs']) {\n\t\tconst candidate = resolve(packageScriptRoot, `${scriptName}${extension}`);\n\t\tif (existsSync(candidate)) {\n\t\t\treturn candidate;\n\t\t}\n\t}\n\n\tthrow new Error(`Unable to resolve package script \"${scriptName}\".`);\n}\n\nexport function runNodeBinary(binPath, args, options = {}) {\n\tconst result = spawnSync(process.execPath, [binPath, ...args], {\n\t\tstdio: options.stdio ?? 'inherit',\n\t\tcwd: options.cwd ?? process.cwd(),\n\t\tenv: { ...process.env, ...(options.env ?? {}) },\n\t});\n\n\tif (result.status !== 0) {\n\t\tprocess.exit(result.status ?? 1);\n\t}\n}\n\nexport function runNodeScript(scriptPath, args = [], options = {}) {\n\treturn runNodeBinary(scriptPath, args, options);\n}\n\nexport function spawnNodeBinary(binPath, args, options = {}) {\n\treturn spawn(process.execPath, [binPath, ...args], {\n\t\tstdio: options.stdio ?? 'inherit',\n\t\tcwd: options.cwd ?? process.cwd(),\n\t\tenv: { ...process.env, ...(options.env ?? {}) },\n\t\tdetached: options.detached ?? false,\n\t});\n}\n"],
  "mappings": "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",
  "names": ["dirname", "extname", "resolve", "require", "resolve", "dirname", "extname"]
}


package/dist/scripts/assert-release-tag-version.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/scripts/assert-release-tag-version.js

@@ -0,0 +1,23 @@
+import { readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+const semverTagPattern = /^\d+\.\d+\.\d+$/;
+const packageRoot = resolve(fileURLToPath(new URL('..', import.meta.url)));
+const packageJsonPath = resolve(packageRoot, 'package.json');
+const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
+const packageVersion = packageJson.version;
+const tagName = process.argv[2] || process.env.GITHUB_REF_NAME;
+if (!tagName) {
+    console.error('Release tag validation requires a tag name argument or GITHUB_REF_NAME.');
+    process.exit(1);
+}
+if (!semverTagPattern.test(tagName)) {
+    console.error(`Release tag "${tagName}" must use the "{MAJOR}.{MINOR}.{PATCH}" format, for example "${packageVersion}".`);
+    process.exit(1);
+}
+const taggedVersion = tagName;
+if (taggedVersion !== packageVersion) {
+    console.error(`Release tag version "${taggedVersion}" does not match @treeseed/sdk version "${packageVersion}".`);
+    process.exit(1);
+}
+console.log(`Release tag "${tagName}" matches @treeseed/sdk version "${packageVersion}".`);

package/dist/scripts/build-dist.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/scripts/build-dist.js

@@ -0,0 +1,114 @@
+import { copyFileSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { dirname, extname, join, relative, resolve } from 'node:path';
+import { build } from 'esbuild';
+import ts from 'typescript';
+import { packageRoot } from './package-tools.js';
+const srcRoot = resolve(packageRoot, 'src');
+const scriptsRoot = resolve(packageRoot, 'scripts');
+const distRoot = resolve(packageRoot, 'dist');
+const COPY_EXTENSIONS = new Set(['.d.js', '.json', '.md']);
+function walkFiles(root) {
+    const files = [];
+    for (const entry of readdirSync(root, { withFileTypes: true })) {
+        const fullPath = join(root, entry.name);
+        if (entry.isDirectory()) {
+            files.push(...walkFiles(fullPath));
+            continue;
+        }
+        files.push(fullPath);
+    }
+    return files;
+}
+function ensureDir(filePath) {
+    mkdirSync(dirname(filePath), { recursive: true });
+}
+function rewriteRuntimeSpecifiers(contents) {
+    return contents.replace(/(['"`])(\.[^'"`\n]+)\.(mjs|ts)\1/g, '$1$2.js$1');
+}
+async function compileModule(filePath, sourceRoot, outputRoot) {
+    const relativePath = relative(sourceRoot, filePath);
+    const outputFile = resolve(outputRoot, relativePath.replace(/\.(mjs|ts)$/u, '.js'));
+    ensureDir(outputFile);
+    await build({
+        entryPoints: [filePath],
+        outfile: outputFile,
+        platform: 'node',
+        format: 'esm',
+        bundle: false,
+        logLevel: 'silent',
+    });
+    const builtSource = readFileSync(outputFile, 'utf8');
+    writeFileSync(outputFile, rewriteRuntimeSpecifiers(builtSource), 'utf8');
+}
+function copyAsset(filePath, sourceRoot, outputRoot) {
+    const outputFile = resolve(outputRoot, relative(sourceRoot, filePath));
+    ensureDir(outputFile);
+    copyFileSync(filePath, outputFile);
+    if (outputFile.endsWith('.d.js')) {
+        const contents = readFileSync(outputFile, 'utf8');
+        writeFileSync(outputFile, rewriteRuntimeSpecifiers(contents), 'utf8');
+    }
+}
+function transpileScript(filePath) {
+    const source = readFileSync(filePath, 'utf8');
+    const relativePath = relative(scriptsRoot, filePath);
+    const outputFile = resolve(distRoot, 'scripts', relativePath.replace(/\.(mjs|ts)$/u, '.js'));
+    const transformed = extname(filePath) === '.ts'
+        ? ts.transpileModule(source, {
+            compilerOptions: {
+                module: ts.ModuleKind.ESNext,
+                target: ts.ScriptTarget.ES2022,
+            },
+        }).outputText
+        : source;
+    ensureDir(outputFile);
+    writeFileSync(outputFile, rewriteRuntimeSpecifiers(transformed), 'utf8');
+}
+function emitDeclarations() {
+    const configPath = ts.findConfigFile(packageRoot, ts.sys.fileExists, 'tsconfig.json');
+    if (!configPath) {
+        throw new Error('Unable to locate tsconfig.json for declaration build.');
+    }
+    const configFile = ts.readConfigFile(configPath, ts.sys.readFile);
+    const parsed = ts.parseJsonConfigFileContent(configFile.config, ts.sys, packageRoot);
+    const program = ts.createProgram({
+        rootNames: parsed.fileNames,
+        options: {
+            ...parsed.options,
+            declaration: true,
+            emitDeclarationOnly: true,
+            declarationDir: distRoot,
+            noEmit: false,
+        },
+    });
+    const result = program.emit();
+    if (result.emitSkipped) {
+        const diagnostics = ts.formatDiagnosticsWithColorAndContext(result.diagnostics, {
+            getCanonicalFileName: (fileName) => fileName,
+            getCurrentDirectory: () => process.cwd(),
+            getNewLine: () => '\n',
+        });
+        throw new Error(`Declaration build failed.\n${diagnostics}`);
+    }
+}
+rmSync(distRoot, { recursive: true, force: true });
+for (const filePath of walkFiles(srcRoot)) {
+    const extension = extname(filePath);
+    if (extension === '.ts') {
+        await compileModule(filePath, srcRoot, distRoot);
+        continue;
+    }
+    if (COPY_EXTENSIONS.has(extension)) {
+        copyAsset(filePath, srcRoot, distRoot);
+    }
+}
+for (const filePath of walkFiles(scriptsRoot)) {
+    const extension = extname(filePath);
+    if (extension === '.ts' || extension === '.mjs') {
+        transpileScript(filePath);
+    }
+}
+emitDeclarations();
+if (existsSync(resolve(packageRoot, 'README.md'))) {
+    copyFileSync(resolve(packageRoot, 'README.md'), resolve(distRoot, '..', 'README.md'));
+}

package/dist/scripts/package-tools.d.ts

@@ -0,0 +1,15 @@
+export declare const packageRoot: string;
+export declare const packageScriptRoot: string;
+export declare function resolveAstroBin(): string;
+export declare function resolveWranglerBin(): string;
+export declare function createProductionBuildEnv(extraEnv?: {}): {
+    TREESEED_LOCAL_DEV_MODE: string;
+    TREESEED_PUBLIC_FORMS_LOCAL_BYPASS_TURNSTILE: string;
+    TREESEED_FORMS_LOCAL_BYPASS_TURNSTILE: string;
+    TREESEED_FORMS_LOCAL_BYPASS_CLOUDFLARE_GUARDS: string;
+    TREESEED_PUBLIC_DEV_WATCH_RELOAD: string;
+};
+export declare function packageScriptPath(scriptName: any): string;
+export declare function runNodeBinary(binPath: any, args: any, options?: {}): void;
+export declare function runNodeScript(scriptPath: any, args?: never[], options?: {}): void;
+export declare function spawnNodeBinary(binPath: any, args: any, options?: {}): import("child_process").ChildProcessWithoutNullStreams;

package/dist/scripts/package-tools.js

@@ -0,0 +1,76 @@
+import { readFileSync } from 'node:fs';
+import { existsSync } from 'node:fs';
+import { dirname, extname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { spawn, spawnSync } from 'node:child_process';
+import { createRequire } from 'node:module';
+const require = createRequire(import.meta.url);
+const scriptRoot = dirname(fileURLToPath(import.meta.url));
+const packageCandidate = resolve(scriptRoot, '..');
+export const packageRoot = packageCandidate.endsWith('/dist')
+    ? resolve(packageCandidate, '..')
+    : packageCandidate;
+export const packageScriptRoot = packageCandidate.endsWith('/dist')
+    ? resolve(packageCandidate, 'scripts')
+    : resolve(packageRoot, 'scripts');
+function resolvePackageBinary(packageName, binName = packageName) {
+    const packageJsonPath = require.resolve(`${packageName}/package.json`);
+    const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
+    const binField = packageJson.bin;
+    const relativePath = typeof binField === 'string'
+        ? binField
+        : binField?.[binName];
+    if (!relativePath) {
+        throw new Error(`Unable to resolve binary "${binName}" from package "${packageName}".`);
+    }
+    return resolve(dirname(packageJsonPath), relativePath);
+}
+export function resolveAstroBin() {
+    return resolvePackageBinary('astro', 'astro');
+}
+export function resolveWranglerBin() {
+    return resolvePackageBinary('wrangler', 'wrangler');
+}
+export function createProductionBuildEnv(extraEnv = {}) {
+    return {
+        TREESEED_LOCAL_DEV_MODE: 'cloudflare',
+        TREESEED_PUBLIC_FORMS_LOCAL_BYPASS_TURNSTILE: '',
+        TREESEED_FORMS_LOCAL_BYPASS_TURNSTILE: '',
+        TREESEED_FORMS_LOCAL_BYPASS_CLOUDFLARE_GUARDS: '',
+        TREESEED_PUBLIC_DEV_WATCH_RELOAD: '',
+        ...extraEnv,
+    };
+}
+export function packageScriptPath(scriptName) {
+    if (extname(scriptName)) {
+        return resolve(packageScriptRoot, scriptName);
+    }
+    for (const extension of ['.js', '.ts', '.mjs']) {
+        const candidate = resolve(packageScriptRoot, `${scriptName}${extension}`);
+        if (existsSync(candidate)) {
+            return candidate;
+        }
+    }
+    throw new Error(`Unable to resolve package script "${scriptName}".`);
+}
+export function runNodeBinary(binPath, args, options = {}) {
+    const result = spawnSync(process.execPath, [binPath, ...args], {
+        stdio: options.stdio ?? 'inherit',
+        cwd: options.cwd ?? process.cwd(),
+        env: { ...process.env, ...(options.env ?? {}) },
+    });
+    if (result.status !== 0) {
+        process.exit(result.status ?? 1);
+    }
+}
+export function runNodeScript(scriptPath, args = [], options = {}) {
+    return runNodeBinary(scriptPath, args, options);
+}
+export function spawnNodeBinary(binPath, args, options = {}) {
+    return spawn(process.execPath, [binPath, ...args], {
+        stdio: options.stdio ?? 'inherit',
+        cwd: options.cwd ?? process.cwd(),
+        env: { ...process.env, ...(options.env ?? {}) },
+        detached: options.detached ?? false,
+    });
+}

package/dist/scripts/publish-package.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/scripts/publish-package.js

@@ -0,0 +1,20 @@
+import { spawnSync } from 'node:child_process';
+import { resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+const packageRoot = resolve(fileURLToPath(new URL('..', import.meta.url)));
+const extraArgs = process.argv.slice(2);
+const npmArgs = ['publish', '.', '--access', 'public'];
+if (process.env.GITHUB_ACTIONS === 'true') {
+    npmArgs.push('--provenance');
+}
+npmArgs.push(...extraArgs);
+const result = spawnSync('npm', npmArgs, {
+    cwd: packageRoot,
+    stdio: 'inherit',
+    env: process.env,
+});
+if (result.error) {
+    console.error(result.error.message);
+    process.exit(1);
+}
+process.exit(result.status ?? 1);

package/dist/scripts/release-verify.d.ts

@@ -0,0 +1 @@
+export {};