outfitter 0.2.5 → 0.2.7

package/dist/shared/outfitter-7r12fj7f.js

@@ -0,0 +1,30 @@
+// @bun
+// apps/outfitter/src/output-mode.ts
+function resolveOutputModeFromContext(flags) {
+  if (flags["json"])
+    return "json";
+  if (flags["jsonl"])
+    return "jsonl";
+  if (process.env["OUTFITTER_JSONL"] === "1")
+    return "jsonl";
+  if (process.env["OUTFITTER_JSON"] === "1")
+    return "json";
+  return "human";
+}
+function resolveStructuredOutputMode(mode) {
+  if (mode !== undefined) {
+    if (mode === "json" || mode === "jsonl") {
+      return mode;
+    }
+    return;
+  }
+  if (process.env["OUTFITTER_JSONL"] === "1") {
+    return "jsonl";
+  }
+  if (process.env["OUTFITTER_JSON"] === "1") {
+    return "json";
+  }
+  return;
+}
+
+export { resolveOutputModeFromContext, resolveStructuredOutputMode };

package/dist/shared/outfitter-8y2dfx6n.js

@@ -0,0 +1,11 @@
+// @bun
+// apps/outfitter/src/engine/types.ts
+class ScaffoldError extends Error {
+  _tag = "ScaffoldError";
+  constructor(message) {
+    super(message);
+    this.name = "ScaffoldError";
+  }
+}
+
+export { ScaffoldError };

package/dist/shared/outfitter-9x1brcmq.js

@@ -0,0 +1,184 @@
+// @bun
+import {
+  ScaffoldError
+} from "./outfitter-8y2dfx6n.js";
+
+// apps/outfitter/src/engine/template.ts
+import {
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  statSync,
+  writeFileSync
+} from "fs";
+import { dirname, extname, join } from "path";
+import { fileURLToPath } from "url";
+import { Result } from "@outfitter/contracts";
+var BINARY_EXTENSIONS = new Set([
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".gif",
+  ".ico",
+  ".webp",
+  ".bmp",
+  ".tiff",
+  ".svg",
+  ".woff",
+  ".woff2",
+  ".ttf",
+  ".otf",
+  ".eot",
+  ".mp3",
+  ".mp4",
+  ".wav",
+  ".ogg",
+  ".webm",
+  ".zip",
+  ".tar",
+  ".gz",
+  ".bz2",
+  ".7z",
+  ".pdf",
+  ".exe",
+  ".dll",
+  ".so",
+  ".dylib",
+  ".node",
+  ".wasm",
+  ".bin",
+  ".dat",
+  ".db",
+  ".sqlite",
+  ".sqlite3"
+]);
+function hasOutfitterPackage(dir) {
+  const packageJsonPath = join(dir, "package.json");
+  if (!existsSync(packageJsonPath)) {
+    return false;
+  }
+  try {
+    const content = readFileSync(packageJsonPath, "utf-8");
+    const parsed = JSON.parse(content);
+    return parsed.name === "outfitter";
+  } catch {
+    return false;
+  }
+}
+function getTemplatesDir() {
+  let currentDir = dirname(fileURLToPath(import.meta.url));
+  for (let i = 0;i < 10; i++) {
+    const templatesPath = join(currentDir, "templates");
+    if (existsSync(templatesPath) && hasOutfitterPackage(currentDir)) {
+      return templatesPath;
+    }
+    currentDir = dirname(currentDir);
+  }
+  const fallback = join(process.cwd(), "apps/outfitter/templates");
+  if (existsSync(fallback)) {
+    return fallback;
+  }
+  return join(process.cwd(), "templates");
+}
+function getOutputFilename(templateFilename) {
+  return templateFilename.endsWith(".template") ? templateFilename.slice(0, -".template".length) : templateFilename;
+}
+function isBinaryFile(filename) {
+  return BINARY_EXTENSIONS.has(extname(filename).toLowerCase());
+}
+function replacePlaceholders(content, values) {
+  return content.replace(/\{\{(\w+)\}\}/g, (match, key) => {
+    if (Object.hasOwn(values, key)) {
+      return values[key];
+    }
+    return match;
+  });
+}
+function copyTemplateFiles(templateDir, targetDir, values, options, copyOptions) {
+  const allowOverwrite = copyOptions?.allowOverwrite ?? false;
+  const relativePrefix = copyOptions?.relativePrefix ?? "";
+  try {
+    if (!existsSync(targetDir)) {
+      if (options.collector) {
+        options.collector.add({
+          type: "dir-create",
+          path: targetDir
+        });
+      } else {
+        mkdirSync(targetDir, { recursive: true });
+      }
+    }
+    const entries = readdirSync(templateDir);
+    for (const entry of entries) {
+      const sourcePath = join(templateDir, entry);
+      const sourceStat = statSync(sourcePath);
+      const relativePath = relativePrefix ? `${relativePrefix}/${entry}` : entry;
+      if (copyOptions?.skipFilter?.(relativePath)) {
+        continue;
+      }
+      if (sourceStat.isDirectory()) {
+        const targetSubDir = join(targetDir, entry);
+        const nestedResult = copyTemplateFiles(sourcePath, targetSubDir, values, options, {
+          ...copyOptions,
+          relativePrefix: relativePath
+        });
+        if (nestedResult.isErr()) {
+          return nestedResult;
+        }
+        continue;
+      }
+      if (!sourceStat.isFile()) {
+        continue;
+      }
+      const outputFilename = getOutputFilename(entry);
+      const targetPath = join(targetDir, outputFilename);
+      const targetExists = existsSync(targetPath);
+      const canOverlay = allowOverwrite && (!targetExists || Boolean(copyOptions?.overwritablePaths?.has(targetPath)));
+      if (targetExists && !options.force && !canOverlay) {
+        if (options.collector) {
+          options.collector.add({
+            type: "file-skip",
+            path: targetPath,
+            reason: "exists"
+          });
+          continue;
+        }
+        return Result.err(new ScaffoldError(`File '${targetPath}' already exists. Use --force to overwrite.`));
+      }
+      if (options.collector) {
+        if (targetExists) {
+          options.collector.add({
+            type: "file-overwrite",
+            path: targetPath,
+            source: "template"
+          });
+        } else {
+          options.collector.add({
+            type: "file-create",
+            path: targetPath,
+            source: "template"
+          });
+        }
+        copyOptions?.writtenPaths?.add(targetPath);
+        continue;
+      }
+      if (isBinaryFile(outputFilename)) {
+        const buffer = readFileSync(sourcePath);
+        writeFileSync(targetPath, buffer);
+        copyOptions?.writtenPaths?.add(targetPath);
+        continue;
+      }
+      const content = readFileSync(sourcePath, "utf-8");
+      const processedContent = replacePlaceholders(content, values);
+      writeFileSync(targetPath, processedContent, "utf-8");
+      copyOptions?.writtenPaths?.add(targetPath);
+    }
+    return Result.ok(undefined);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    return Result.err(new ScaffoldError(`Failed to copy template files: ${message}`));
+  }
+}
+
+export { getTemplatesDir, getOutputFilename, isBinaryFile, replacePlaceholders, copyTemplateFiles };

package/dist/shared/outfitter-a79xrm12.d.ts

@@ -0,0 +1,17 @@
+import { OutputMode } from "@outfitter/cli/types";
+type StructuredOutputMode = Extract<OutputMode, "json" | "jsonl">;
+/** Output modes resolvable from CLI flags and env vars. */
+type CliOutputMode = "human" | "json" | "jsonl";
+/**
+* Resolve output mode from CLI context (flags + env vars).
+*
+* Precedence: explicit flag > OUTFITTER_JSONL env > OUTFITTER_JSON env > "human"
+*
+* This function is pure -- no env var side effects.
+*/
+declare function resolveOutputModeFromContext(flags: Record<string, unknown>): CliOutputMode;
+/**
+* Resolve machine-readable output mode from explicit options first, then env.
+*/
+declare function resolveStructuredOutputMode(mode?: OutputMode): StructuredOutputMode | undefined;
+export { StructuredOutputMode, CliOutputMode, resolveOutputModeFromContext, resolveStructuredOutputMode };

package/dist/shared/outfitter-amc4jbs1.d.ts

@@ -0,0 +1,50 @@
+type Operation = {
+	readonly type: "file-create";
+	readonly path: string;
+	readonly source: "template" | "block" | "generated";
+} | {
+	readonly type: "file-overwrite";
+	readonly path: string;
+	readonly source: "template" | "block" | "generated";
+} | {
+	readonly type: "file-skip";
+	readonly path: string;
+	readonly reason: string;
+} | {
+	readonly type: "dir-create";
+	readonly path: string;
+} | {
+	readonly type: "dependency-add";
+	readonly name: string;
+	readonly version: string;
+	readonly section: "dependencies" | "devDependencies" | "peerDependencies";
+} | {
+	readonly type: "block-add";
+	readonly name: string;
+	readonly files: readonly string[];
+} | {
+	readonly type: "config-inject";
+	readonly target: string;
+	readonly description: string;
+} | {
+	readonly type: "git";
+	readonly action: "init" | "add-all" | "commit";
+	readonly cwd: string;
+	readonly message?: string | undefined;
+} | {
+	readonly type: "install";
+	readonly command: string;
+	readonly cwd: string;
+};
+declare class OperationCollector {
+	private readonly operations;
+	add(op: Operation): void;
+	getOperations(): readonly Operation[];
+	countByType(): Record<string, number>;
+	isEmpty(): boolean;
+	toJSON(): {
+		operations: readonly Operation[];
+		summary: Record<string, number>;
+	};
+}
+export { Operation, OperationCollector };

package/dist/shared/outfitter-bn9c8p2e.js

@@ -0,0 +1,204 @@
+// @bun
+import {
+  loadDocsModule
+} from "./outfitter-zwyvewr1.js";
+
+// apps/outfitter/src/commands/repo.ts
+import { existsSync } from "fs";
+import { createRequire } from "module";
+import { dirname, join } from "path";
+import {
+  booleanFlagPreset,
+  composePresets,
+  cwdPreset,
+  stringListFlagPreset
+} from "@outfitter/cli/flags";
+import {
+  resolveDocsCliOptions,
+  withDocsCommonOptions,
+  withDocsExportOptions
+} from "@outfitter/docs";
+import { Command } from "commander";
+var require2 = createRequire(import.meta.url);
+function getIo(options) {
+  return {
+    out: options?.io?.out ?? ((line) => process.stdout.write(`${line}
+`)),
+    err: options?.io?.err ?? ((line) => process.stderr.write(`${line}
+`))
+  };
+}
+function resolveToolingCliEntrypoint() {
+  const packageJsonPath = require2.resolve("@outfitter/tooling/package.json");
+  const packageRoot = dirname(packageJsonPath);
+  const srcEntrypoint = join(packageRoot, "src", "cli", "index.ts");
+  if (existsSync(srcEntrypoint)) {
+    return srcEntrypoint;
+  }
+  const distEntrypoint = join(packageRoot, "dist", "cli", "index.js");
+  if (existsSync(distEntrypoint)) {
+    return distEntrypoint;
+  }
+  throw new Error("Unable to resolve @outfitter/tooling CLI entrypoint (expected dist/cli/index.js or src/cli/index.ts).");
+}
+async function runDocsCheckDefault(options, io) {
+  const docsModule = await loadDocsModule();
+  return await docsModule.executeCheckCommand(options, io);
+}
+async function runDocsSyncDefault(options, io) {
+  const docsModule = await loadDocsModule();
+  return await docsModule.executeSyncCommand(options, io);
+}
+async function runDocsExportDefault(options, io) {
+  const docsModule = await loadDocsModule();
+  return await docsModule.executeExportCommand(options, io);
+}
+async function runToolingCommandDefault(input) {
+  const toolingCliEntrypoint = resolveToolingCliEntrypoint();
+  const child = Bun.spawn([process.execPath, toolingCliEntrypoint, input.command, ...input.args], {
+    cwd: input.cwd,
+    stdin: "inherit",
+    stdout: "inherit",
+    stderr: "inherit"
+  });
+  return await child.exited;
+}
+function applyExitCode(code) {
+  if (code !== 0) {
+    process.exitCode = code;
+  }
+}
+function applyPresetOptions(command, preset) {
+  for (const option of preset.options) {
+    command.option(option.flags, option.description, option.defaultValue);
+  }
+  return command;
+}
+function addDocsCheckSubcommand(command, options) {
+  const docsCheckCommand = command.command("docs").description("Check whether assembled package docs are in sync");
+  withDocsCommonOptions(docsCheckCommand).action(async (cmdOptions) => {
+    const code = await options.runDocsCheck(resolveDocsCliOptions(cmdOptions), options.io);
+    applyExitCode(code);
+  });
+}
+function addDocsSyncSubcommand(command, options) {
+  const docsSyncCommand = command.command("docs").description("Assemble package docs into docs/packages");
+  withDocsCommonOptions(docsSyncCommand).action(async (cmdOptions) => {
+    const code = await options.runDocsSync(resolveDocsCliOptions(cmdOptions), options.io);
+    applyExitCode(code);
+  });
+}
+function addDocsExportSubcommand(command, options) {
+  const docsExportCommand = command.command("docs").description("Export docs artifacts for packages and LLM targets");
+  withDocsExportOptions(docsExportCommand).action(async (cmdOptions) => {
+    const code = await options.runDocsExport(resolveDocsCliOptions(cmdOptions), options.io);
+    applyExitCode(code);
+  });
+}
+function addToolingCheckSubcommands(command, runToolingCommand) {
+  const cwdFlag = cwdPreset();
+  const jsonFlag = booleanFlagPreset({
+    id: "repo-check-json",
+    key: "json",
+    flags: "--json",
+    description: "Output results as JSON"
+  });
+  const skipFlag = booleanFlagPreset({
+    id: "repo-check-skip",
+    key: "skip",
+    flags: "-s, --skip",
+    description: "Skip changeset check"
+  });
+  const pathsFlag = stringListFlagPreset({
+    id: "repo-check-paths",
+    key: "paths",
+    flags: "--paths <paths...>",
+    description: "Limit check to specific paths"
+  });
+  const toolingWithCwd = composePresets(cwdFlag);
+  const toolingWithJsonAndCwd = composePresets(jsonFlag, cwdFlag);
+  const toolingWithSkipAndCwd = composePresets(skipFlag, cwdFlag);
+  const toolingWithPathsAndCwd = composePresets(pathsFlag, cwdFlag);
+  function registerToolingCheckSubcommand(config) {
+    const subcommand = command.command(config.name).description(config.description);
+    applyPresetOptions(subcommand, config.preset);
+    subcommand.action(async (cmdOptions) => {
+      const resolved = config.preset.resolve(cmdOptions);
+      const cwd = resolveDocsCliOptions({ cwd: resolved.cwd }).cwd || process.cwd();
+      const code = await runToolingCommand({
+        command: config.toolingCommand,
+        args: config.buildArgs(resolved),
+        cwd
+      });
+      applyExitCode(code);
+    });
+  }
+  registerToolingCheckSubcommand({
+    name: "exports",
+    description: "Validate package.json exports match source entry points",
+    toolingCommand: "check-exports",
+    preset: toolingWithJsonAndCwd,
+    buildArgs: (resolved) => resolved["json"] ? ["--json"] : []
+  });
+  registerToolingCheckSubcommand({
+    name: "readme",
+    description: "Validate README import examples match package exports",
+    toolingCommand: "check-readme-imports",
+    preset: toolingWithJsonAndCwd,
+    buildArgs: (resolved) => resolved["json"] ? ["--json"] : []
+  });
+  registerToolingCheckSubcommand({
+    name: "registry",
+    description: "Validate packages with bunup --filter are registered in bunup.config.ts",
+    toolingCommand: "check-bunup-registry",
+    preset: toolingWithCwd,
+    buildArgs: () => []
+  });
+  registerToolingCheckSubcommand({
+    name: "changeset",
+    description: "Validate PRs touching package source include a changeset",
+    toolingCommand: "check-changeset",
+    preset: toolingWithSkipAndCwd,
+    buildArgs: (resolved) => resolved["skip"] ? ["--skip"] : []
+  });
+  registerToolingCheckSubcommand({
+    name: "tree",
+    description: "Assert working tree is clean (no modified or untracked files)",
+    toolingCommand: "check-clean-tree",
+    preset: toolingWithPathsAndCwd,
+    buildArgs: (resolved) => Array.isArray(resolved["paths"]) && resolved["paths"].length > 0 ? ["--paths", ...resolved["paths"]] : []
+  });
+  registerToolingCheckSubcommand({
+    name: "boundary-invocations",
+    description: "Validate root/app scripts do not execute packages/*/src entrypoints directly",
+    toolingCommand: "check-boundary-invocations",
+    preset: toolingWithCwd,
+    buildArgs: () => []
+  });
+}
+function createRepoCommand(options) {
+  const io = getIo(options);
+  const runDocsCheck = options?.runDocsCheck ?? runDocsCheckDefault;
+  const runDocsSync = options?.runDocsSync ?? runDocsSyncDefault;
+  const runDocsExport = options?.runDocsExport ?? runDocsExportDefault;
+  const runToolingCommand = options?.runToolingCommand ?? runToolingCommandDefault;
+  const command = new Command(options?.commandName ?? "repo");
+  command.description("Repository maintenance commands");
+  const checkCommand = command.command("check").description("Run repository checks by subject");
+  addDocsCheckSubcommand(checkCommand, { io, runDocsCheck });
+  addToolingCheckSubcommands(checkCommand, runToolingCommand);
+  const syncCommand = command.command("sync").description("Synchronize repository artifacts by subject");
+  addDocsSyncSubcommand(syncCommand, { io, runDocsSync });
+  const exportCommand = command.command("export").description("Export repository artifacts by subject");
+  addDocsExportSubcommand(exportCommand, { io, runDocsExport });
+  return command;
+}
+async function main() {
+  const command = createRepoCommand({ commandName: "repo" });
+  await command.parseAsync(process.argv, { from: "node" });
+}
+if (import.meta.main) {
+  main();
+}
+
+export { createRepoCommand };

package/dist/shared/outfitter-bpr28y54.js

@@ -0,0 +1,70 @@
+// @bun
+// apps/outfitter/src/commands/upgrade-planner.ts
+function getMajor(version) {
+  const parts = version.split(".");
+  return Number.parseInt(parts[0] ?? "0", 10);
+}
+function getMinor(version) {
+  const parts = version.split(".");
+  return Number.parseInt(parts[1] ?? "0", 10);
+}
+function isBreaking(currentVersion, latestVersion, breakingFlag) {
+  if (breakingFlag === true)
+    return true;
+  if (breakingFlag === false)
+    return false;
+  const currentMajor = getMajor(currentVersion);
+  const latestMajor = getMajor(latestVersion);
+  if (latestMajor > currentMajor) {
+    return true;
+  }
+  if (currentMajor === 0) {
+    const currentMinor = getMinor(currentVersion);
+    const latestMinor = getMinor(latestVersion);
+    if (latestMinor > currentMinor) {
+      return true;
+    }
+  }
+  return false;
+}
+function classify(currentVersion, latestVersion, breakingFlag) {
+  if (Bun.semver.order(latestVersion, currentVersion) <= 0) {
+    return "upToDate";
+  }
+  if (isBreaking(currentVersion, latestVersion, breakingFlag)) {
+    return "upgradableBreaking";
+  }
+  return "upgradableNonBreaking";
+}
+function analyzeUpgrades(installed, latest, migrationDocs) {
+  const packages = [];
+  for (const [name, currentVersion] of installed) {
+    const latestInfo = latest.get(name);
+    const latestVersion = latestInfo?.version ?? currentVersion;
+    const breakingFlag = latestInfo?.breaking;
+    const classification = classify(currentVersion, latestVersion, breakingFlag);
+    const breaking = classification === "upgradableBreaking";
+    const migrationDoc = migrationDocs?.get(name);
+    packages.push({
+      name,
+      currentVersion,
+      latestVersion,
+      classification,
+      breaking,
+      ...migrationDoc !== undefined ? { migrationDoc } : {}
+    });
+  }
+  packages.sort((a, b) => a.name.localeCompare(b.name));
+  const summary = {
+    upToDate: 0,
+    upgradableNonBreaking: 0,
+    upgradableBreaking: 0,
+    blocked: 0
+  };
+  for (const pkg of packages) {
+    summary[pkg.classification]++;
+  }
+  return { packages, summary };
+}
+
+export { analyzeUpgrades };

package/dist/shared/outfitter-dpj9erew.d.ts

@@ -0,0 +1,4 @@
+import { CreateProjectInput, CreateProjectPlan } from "./outfitter-e9rrfekb.js";
+import { Result, ValidationError } from "@outfitter/contracts";
+declare function planCreateProject(input: CreateProjectInput): Result<CreateProjectPlan, ValidationError>;
+export { planCreateProject };

package/dist/shared/outfitter-e9rrfekb.d.ts

@@ -0,0 +1,51 @@
+/**
+* Create planner types for kit-first project scaffolding.
+*
+* These types model preset intent separately from execution so future flows can
+* consume a deterministic plan before mutating the filesystem.
+*/
+type CreatePresetId = "basic" | "cli" | "daemon" | "mcp";
+interface CreatePresetDefinition {
+	readonly defaultBlocks: readonly string[];
+	readonly id: CreatePresetId;
+	readonly summary: string;
+	readonly template: CreatePresetId;
+}
+interface CreateProjectInput {
+	readonly description?: string;
+	readonly includeTooling?: boolean;
+	readonly local?: boolean;
+	readonly name: string;
+	readonly packageName?: string;
+	readonly preset: CreatePresetId;
+	readonly targetDir: string;
+	readonly version?: string;
+	readonly year?: string;
+}
+type CreatePlanChange = {
+	readonly type: "copy-template";
+	readonly template: string;
+	readonly targetDir: string;
+	readonly overlayBaseTemplate: boolean;
+} | {
+	readonly type: "inject-shared-config";
+} | {
+	readonly type: "rewrite-local-dependencies";
+	readonly mode: "workspace";
+} | {
+	readonly type: "add-blocks";
+	readonly blocks: readonly string[];
+};
+interface CreateProjectPlan {
+	readonly changes: readonly CreatePlanChange[];
+	readonly preset: CreatePresetDefinition;
+	readonly values: {
+		readonly packageName: string;
+		readonly projectName: string;
+		readonly version: string;
+		readonly description: string;
+		readonly binName: string;
+		readonly year: string;
+	};
+}
+export { CreatePresetId, CreatePresetDefinition, CreateProjectInput, CreatePlanChange, CreateProjectPlan };

package/dist/shared/outfitter-ehp18x1n.js

@@ -0,0 +1 @@
+// @bun

package/dist/shared/outfitter-f9znfhkn.d.ts

@@ -0,0 +1,5 @@
+import { ScaffoldError } from "./outfitter-n9g1zk4x.js";
+import { Result } from "@outfitter/contracts";
+declare function injectSharedConfig(targetDir: string): Result<void, ScaffoldError>;
+declare function rewriteLocalDependencies(targetDir: string): Result<void, ScaffoldError>;
+export { injectSharedConfig, rewriteLocalDependencies };

package/dist/shared/outfitter-fhnjpjwc.d.ts

@@ -0,0 +1,18 @@
+import { ScaffoldError } from "./outfitter-n9g1zk4x.js";
+import { Result } from "@outfitter/contracts";
+declare function buildWorkspaceRootReadme(workspaceName: string): string;
+declare function buildWorkspaceRootPackageJson(workspaceName: string): string;
+declare function scaffoldWorkspaceRoot(rootDir: string, workspaceName: string, force: boolean): Result<void, ScaffoldError>;
+/**
+* Extracts workspace glob patterns from a package.json `workspaces` field.
+*
+* Handles both array form (`["apps/*"]`) and object form (`{ packages: ["apps/*"] }`).
+*/
+declare function getWorkspacePatterns(workspaces: unknown): readonly string[];
+interface PackageDeps {
+	workspaces?: unknown;
+	[key: string]: unknown;
+}
+declare function hasWorkspacesField(pkg: PackageDeps): boolean;
+declare function detectWorkspaceRoot(cwd: string): Result<string | null, ScaffoldError>;
+export { buildWorkspaceRootReadme, buildWorkspaceRootPackageJson, scaffoldWorkspaceRoot, getWorkspacePatterns, hasWorkspacesField, detectWorkspaceRoot };

package/dist/shared/outfitter-fn20r49x.d.ts

@@ -0,0 +1,5 @@
+import { EngineOptions, ScaffoldError } from "./outfitter-n9g1zk4x.js";
+import { Result } from "@outfitter/contracts";
+import { AddBlockResult } from "@outfitter/tooling";
+declare function addBlocks(targetDir: string, blocks: readonly string[], options: EngineOptions): Promise<Result<AddBlockResult, ScaffoldError>>;
+export { addBlocks };