outfitter 0.3.2 → 0.3.3

package/dist/shared/outfitter-x4cc5xsq.js

@@ -0,0 +1,168 @@
+// @bun
+import {
+  findMigrationDocsDir,
+  readMigrationDocs
+} from "./outfitter-fx1m251y.js";
+import {
+  resolveStructuredOutputMode
+} from "./outfitter-7r12fj7f.js";
+
+// apps/outfitter/src/commands/upgrade-output.ts
+import { output } from "@outfitter/cli";
+import { createTheme } from "@outfitter/tui/render";
+async function printUpgradeResults(result, options) {
+  const structuredMode = resolveStructuredOutputMode(options?.mode);
+  if (structuredMode) {
+    await output(result, { mode: structuredMode });
+    return;
+  }
+  const theme = createTheme();
+  const lines = ["", "Outfitter Upgrade", "", "=".repeat(60)];
+  if (result.packages.length === 0) {
+    lines.push("No @outfitter/* packages found in package.json.");
+    if (!result.unknownPackages || result.unknownPackages.length === 0) {
+      await output(lines, { mode: "human" });
+      return;
+    }
+    lines.push("");
+  } else {
+    lines.push(`  ${"Package".padEnd(28)} ${"Current".padEnd(10)} ${"Available".padEnd(10)} Migration`);
+    lines.push(`  ${"\u2500".repeat(28)} ${"\u2500".repeat(10)} ${"\u2500".repeat(10)} ${"\u2500".repeat(20)}`);
+    for (const pkg of result.packages) {
+      const name = pkg.name.padEnd(28);
+      const current = pkg.current.padEnd(10);
+      const available = (pkg.latest ?? "unknown").padEnd(10);
+      let migration;
+      if (pkg.latest === null) {
+        migration = theme.muted("lookup failed");
+      } else if (!pkg.updateAvailable) {
+        migration = theme.muted("up to date");
+      } else if (pkg.breaking) {
+        migration = theme.error("breaking");
+      } else {
+        migration = theme.success("non-breaking");
+      }
+      lines.push(`  ${name} ${current} ${available} ${migration}`);
+    }
+    lines.push("");
+  }
+  if (result.applied && result.appliedPackages.length > 0) {
+    const breakingApplied = result.appliedPackages.filter((name) => result.packages.some((p) => p.name === name && p.breaking));
+    const nonBreakingApplied = result.appliedPackages.filter((name) => !result.packages.some((p) => p.name === name && p.breaking));
+    if (nonBreakingApplied.length > 0) {
+      lines.push(theme.success(`Applied ${nonBreakingApplied.length} non-breaking upgrade(s):`));
+      for (const name of nonBreakingApplied) {
+        lines.push(`  - ${name}`);
+      }
+      lines.push("");
+    }
+    if (breakingApplied.length > 0) {
+      lines.push(theme.error(`Applied ${breakingApplied.length} breaking upgrade(s):`));
+      for (const name of breakingApplied) {
+        const pkg = result.packages.find((p) => p.name === name);
+        lines.push(`  - ${name} (${pkg?.current} -> ${pkg?.latest})`);
+      }
+      lines.push("", theme.muted("Review migration guides: 'outfitter upgrade --guide'"));
+      lines.push("");
+    }
+  }
+  if (result.skippedBreaking.length > 0 && options?.all !== true) {
+    if (result.applied) {
+      lines.push(theme.error(`Skipped ${result.skippedBreaking.length} breaking upgrade(s):`));
+    } else {
+      lines.push("  Excluded (breaking):");
+    }
+    for (const name of result.skippedBreaking) {
+      const pkg = result.packages.find((p) => p.name === name);
+      const codemodHint = pkg?.breaking ? "(migration guide)" : "";
+      lines.push(`    ${name.padEnd(24)} ${(pkg?.current ?? "").padEnd(8)} -> ${(pkg?.latest ?? "").padEnd(8)} ${codemodHint}`.trimEnd());
+    }
+    lines.push("", theme.muted("  Use --all to include breaking changes"));
+    lines.push("");
+  }
+  if (result.codemods !== undefined) {
+    const uniqueChangedFiles = [
+      ...new Set(result.codemods.changedFiles)
+    ].toSorted();
+    lines.push(theme.info(`Ran ${result.codemods.codemodCount} codemod(s).`));
+    if (uniqueChangedFiles.length > 0) {
+      lines.push(theme.success(`Codemods changed ${uniqueChangedFiles.length} file(s):`));
+      for (const file of uniqueChangedFiles) {
+        lines.push(`  - ${file}`);
+      }
+    }
+    if (result.codemods.errors.length > 0) {
+      lines.push(theme.error(`Codemod errors (${result.codemods.errors.length}):`));
+      for (const error of result.codemods.errors) {
+        lines.push(`  - ${error}`);
+      }
+    }
+    lines.push("");
+  }
+  if (result.conflicts && result.conflicts.length > 0) {
+    lines.push(theme.warning(`Version conflict(s) across workspace (${result.conflicts.length}):`));
+    for (const conflict of result.conflicts) {
+      lines.push(`  ${conflict.name}`);
+      for (const entry of conflict.versions) {
+        const manifests = entry.manifests.map((m) => {
+          const dir = m.replace(/\/package\.json$/, "");
+          const parts = dir.split("/");
+          return parts.slice(-2).join("/");
+        }).join(", ");
+        lines.push(`    ${entry.version.padEnd(10)} ${theme.muted(manifests)}`);
+      }
+    }
+    lines.push("");
+  }
+  if (result.unknownPackages && result.unknownPackages.length > 0) {
+    lines.push(theme.error("Unknown package(s) not found in workspace:"));
+    for (const name of result.unknownPackages) {
+      lines.push(`  - ${name}`);
+    }
+    lines.push("");
+  }
+  if (!result.applied) {
+    if (options?.dryRun) {
+      lines.push(theme.muted("Dry run \u2014 no changes applied."));
+    } else if (result.updatesAvailable > 0) {
+      lines.push(theme.muted("Run 'outfitter upgrade --guide' for migration instructions."));
+    } else {
+      lines.push(theme.success("All packages are up to date."));
+    }
+  }
+  if (options?.guide && result.guides && result.guides.length > 0) {
+    lines.push("", "=".repeat(60), "", "Migration Guide", "");
+    for (const guide of result.guides) {
+      const label = guide.breaking ? theme.error("BREAKING") : theme.success("non-breaking");
+      lines.push(`${theme.info(guide.packageName)} ${guide.fromVersion} -> ${guide.toVersion} [${label}]`);
+      if (guide.steps.length > 0) {
+        for (const step of guide.steps) {
+          lines.push(`  ${step}`);
+        }
+      } else {
+        lines.push(`  ${theme.muted("No migration steps available. Check release notes.")}`);
+      }
+      lines.push("");
+    }
+  } else if (options?.guide && result.updatesAvailable > 0 && !result.guides) {
+    const cwd = options.cwd ?? process.cwd();
+    const migrationsDir = findMigrationDocsDir(cwd);
+    if (migrationsDir) {
+      lines.push("", "=".repeat(60), "", "Migration Guide", "");
+      for (const pkg of result.packages) {
+        if (!(pkg.updateAvailable && pkg.latest))
+          continue;
+        const shortName = pkg.name.replace("@outfitter/", "");
+        const docs = readMigrationDocs(migrationsDir, shortName, pkg.current, pkg.latest);
+        for (const doc of docs) {
+          lines.push(doc, "", "---", "");
+        }
+      }
+    } else {
+      lines.push("", theme.muted("Migration docs not found locally. See https://github.com/outfitter-dev/outfitter for migration guides."));
+    }
+  }
+  await output(lines, { mode: "human" });
+}
+
+export { printUpgradeResults };

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

@@ -0,0 +1,39 @@
+import { CliOutputMode } from "./outfitter-a79xrm12.js";
+import { DocsExportTarget, loadDocsModule } from "./outfitter-1tfa9hke.js";
+import { InternalError, Result } from "@outfitter/contracts";
+/** Validated input for the docs.action handler. */
+interface DocsExportInput {
+	readonly cwd: string;
+	readonly outputMode: CliOutputMode;
+	readonly target: DocsExportTarget;
+}
+/** Output shape for the docs.action. */
+interface DocsExportOutput {
+	readonly exitCode: number;
+	readonly messages: string[];
+	readonly target: string;
+	readonly warnings: string[];
+}
+interface DocsExportDependencies {
+	readonly loadDocsModule?: typeof loadDocsModule;
+}
+/**
+* Export documentation to the specified target format.
+*
+* Delegates to `executeExportCommand` from "@outfitter/docs" via the
+* dynamic module loader.
+*
+* @param input - Validated action input
+* @returns Result containing the output or an error
+*/
+declare function runDocsExport(input: DocsExportInput, dependencies?: DocsExportDependencies): Promise<Result<DocsExportOutput, InternalError>>;
+/**
+* Print docs results in the appropriate output format.
+*
+* @param result - The docs output
+* @param options - Output formatting options
+*/
+declare function printDocsExportResults(result: DocsExportOutput, options?: {
+	mode?: CliOutputMode;
+}): Promise<void>;
+export { DocsExportInput, DocsExportOutput, runDocsExport, printDocsExportResults };

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

@@ -0,0 +1,50 @@
+type Operation = {
+	readonly type: "file-create";
+	readonly path: string;
+	readonly source: "preset" | "block" | "generated";
+} | {
+	readonly type: "file-overwrite";
+	readonly path: string;
+	readonly source: "preset" | "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-xs94pkfe.js

@@ -0,0 +1,106 @@
+// @bun
+import {
+  actionInternalErr,
+  outputModeSchema,
+  resolveBooleanFlagAlias,
+  resolveInstallTimeoutFlag,
+  resolveLocalFlag,
+  resolveNoToolingFlag,
+  resolveStringFlag
+} from "./outfitter-7n7vsz95.js";
+import {
+  runScaffold
+} from "./outfitter-6ddf91vh.js";
+import {
+  printScaffoldResults
+} from "./outfitter-qsrx7m4w.js";
+import {
+  resolveOutputModeFromContext
+} from "./outfitter-7r12fj7f.js";
+
+// apps/outfitter/src/actions/scaffold.ts
+import { actionCliPresets } from "@outfitter/cli/actions";
+import { dryRunPreset, forcePreset } from "@outfitter/cli/flags";
+import { defineAction, Result } from "@outfitter/contracts";
+import { z } from "zod";
+var scaffoldInputSchema = z.object({
+  target: z.string(),
+  name: z.string().optional(),
+  force: z.boolean(),
+  skipInstall: z.boolean(),
+  dryRun: z.boolean(),
+  with: z.string().optional(),
+  noTooling: z.boolean().optional(),
+  local: z.boolean().optional(),
+  installTimeout: z.number().optional(),
+  cwd: z.string(),
+  outputMode: outputModeSchema
+});
+var scaffoldSharedFlags = actionCliPresets(forcePreset(), dryRunPreset());
+function resolveScaffoldOptions(context) {
+  const flags = context.flags;
+  const { force, dryRun } = scaffoldSharedFlags.resolve(context);
+  const outputMode = resolveOutputModeFromContext(context.flags);
+  const noTooling = resolveNoToolingFlag(flags);
+  const local = resolveLocalFlag(flags);
+  const installTimeout = resolveInstallTimeoutFlag(flags.installTimeout);
+  return {
+    target: String(context.args[0] ?? ""),
+    name: resolveStringFlag(context.args[1]),
+    force,
+    skipInstall: resolveBooleanFlagAlias(context.flags, "skipInstall", "skip-install"),
+    dryRun,
+    ...local !== undefined ? { local } : {},
+    with: resolveStringFlag(flags.with),
+    ...noTooling !== undefined ? { noTooling } : {},
+    ...installTimeout !== undefined ? { installTimeout } : {},
+    cwd: process.cwd(),
+    outputMode
+  };
+}
+var scaffoldAction = defineAction({
+  id: "scaffold",
+  description: "Add a capability to an existing project",
+  surfaces: ["cli"],
+  input: scaffoldInputSchema,
+  cli: {
+    command: "scaffold <target> [name]",
+    description: "Add a capability (cli, mcp, daemon, lib, ...) to an existing project",
+    options: [
+      ...scaffoldSharedFlags.options,
+      {
+        flags: "--skip-install",
+        description: "Skip bun install",
+        defaultValue: false
+      },
+      {
+        flags: "--with <blocks>",
+        description: "Comma-separated tooling blocks to add"
+      },
+      {
+        flags: "--no-tooling",
+        description: "Skip default tooling blocks"
+      },
+      {
+        flags: "--local",
+        description: "Use workspace:* for @outfitter dependencies"
+      },
+      {
+        flags: "--install-timeout <ms>",
+        description: "bun install timeout in milliseconds"
+      }
+    ],
+    mapInput: resolveScaffoldOptions
+  },
+  handler: async (input) => {
+    const { outputMode, ...scaffoldInput } = input;
+    const result = await runScaffold(scaffoldInput);
+    if (result.isErr()) {
+      return actionInternalErr("scaffold", result.error);
+    }
+    await printScaffoldResults(result.value, { mode: outputMode });
+    return Result.ok(result.value);
+  }
+});
+
+export { scaffoldAction };

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

@@ -0,0 +1,37 @@
+/**
+* Structured migration doc frontmatter parsing for `outfitter upgrade`.
+*
+* @packageDocumentation
+*/
+/** Classification of a change within a migration. */
+type MigrationChangeType = "renamed" | "removed" | "signature-changed" | "moved" | "deprecated" | "added";
+/** A single structured change entry from migration frontmatter. */
+interface MigrationChange {
+	/** Path to codemod script relative to the codemods directory. */
+	readonly codemod?: string;
+	readonly detail?: string;
+	readonly export?: string;
+	readonly from?: string;
+	readonly path?: string;
+	readonly to?: string;
+	readonly type: MigrationChangeType;
+}
+/** Parsed frontmatter from a migration doc. */
+interface MigrationFrontmatter {
+	readonly breaking: boolean;
+	readonly changes?: readonly MigrationChange[];
+	readonly package: string;
+	readonly version: string;
+}
+/**
+* Strip a YAML frontmatter block from migration doc content.
+*/
+declare function stripMigrationFrontmatter(content: string): string;
+/**
+* Parse the full frontmatter from a migration doc, including the `changes` array.
+*
+* Returns `null` if the content has no valid frontmatter or is missing
+* required fields (`package`, `version`, `breaking`).
+*/
+declare function parseMigrationFrontmatter(content: string): MigrationFrontmatter | null;
+export { MigrationChangeType, MigrationChange, MigrationFrontmatter, stripMigrationFrontmatter, parseMigrationFrontmatter };

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

@@ -0,0 +1,18 @@
+import { ScaffoldError } from "./outfitter-cyvr4r8d.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-ydw7x6bh.js

@@ -0,0 +1,61 @@
+// @bun
+import {
+  runAdd
+} from "./outfitter-3tx3adgj.js";
+import {
+  ScaffoldError
+} from "./outfitter-8y2dfx6n.js";
+
+// apps/outfitter/src/engine/blocks.ts
+import { Result } from "@outfitter/contracts";
+async function addBlocks(targetDir, blocks, options) {
+  const mergedResult = {
+    created: [],
+    skipped: [],
+    overwritten: [],
+    dependencies: {},
+    devDependencies: {}
+  };
+  for (const blockName of blocks) {
+    const result = await runAdd({
+      block: blockName,
+      force: options.force,
+      dryRun: Boolean(options.collector),
+      cwd: targetDir
+    });
+    if (result.isErr()) {
+      return Result.err(new ScaffoldError(`Failed to add block '${blockName}': ${result.error.message}`));
+    }
+    if (options.collector) {
+      options.collector.add({
+        type: "block-add",
+        name: blockName,
+        files: [...result.value.created, ...result.value.overwritten]
+      });
+      for (const [name, version] of Object.entries(result.value.dependencies)) {
+        options.collector.add({
+          type: "dependency-add",
+          name,
+          version,
+          section: "dependencies"
+        });
+      }
+      for (const [name, version] of Object.entries(result.value.devDependencies)) {
+        options.collector.add({
+          type: "dependency-add",
+          name,
+          version,
+          section: "devDependencies"
+        });
+      }
+    }
+    mergedResult.created.push(...result.value.created);
+    mergedResult.skipped.push(...result.value.skipped);
+    mergedResult.overwritten.push(...result.value.overwritten);
+    Object.assign(mergedResult.dependencies, result.value.dependencies);
+    Object.assign(mergedResult.devDependencies, result.value.devDependencies);
+  }
+  return Result.ok(mergedResult);
+}
+
+export { addBlocks };

package/dist/shared/outfitter-yhb23pjc.js

@@ -0,0 +1,89 @@
+// @bun
+import {
+  applyJq
+} from "./outfitter-5vx1bp7h.js";
+import {
+  loadDocsModule
+} from "./outfitter-svts4wk2.js";
+import {
+  resolveStructuredOutputMode
+} from "./outfitter-7r12fj7f.js";
+
+// apps/outfitter/src/commands/docs-list.ts
+import { resolve } from "path";
+import { output } from "@outfitter/cli";
+import { InternalError, Result } from "@outfitter/contracts";
+import { createTheme } from "@outfitter/tui/render";
+async function runDocsList(input) {
+  try {
+    const cwd = resolve(input.cwd);
+    const docsModule = await loadDocsModule();
+    const mapResult = await docsModule.generateDocsMap({ workspaceRoot: cwd });
+    if (mapResult.isErr()) {
+      return Result.err(new InternalError({
+        message: mapResult.error.message,
+        context: { action: "docs.list" }
+      }));
+    }
+    const rawMap = mapResult.value;
+    let entries = rawMap.entries.map((entry) => ({
+      id: entry.id,
+      kind: entry.kind,
+      title: entry.title,
+      sourcePath: entry.sourcePath,
+      outputPath: entry.outputPath,
+      ...entry.package !== undefined ? { package: entry.package } : {}
+    }));
+    if (input.kind) {
+      entries = entries.filter((entry) => entry.kind === input.kind);
+    }
+    if (input.package) {
+      entries = entries.filter((entry) => entry.package === input.package);
+    }
+    return Result.ok({
+      entries,
+      total: entries.length
+    });
+  } catch (error) {
+    return Result.err(new InternalError({
+      message: error instanceof Error ? error.message : "Failed to list docs",
+      context: { action: "docs.list" }
+    }));
+  }
+}
+async function printDocsListResults(result, options) {
+  const structuredMode = resolveStructuredOutputMode(options?.mode);
+  if (structuredMode) {
+    if (options?.jq) {
+      const filtered = await applyJq(result, options.jq, {
+        compact: structuredMode === "jsonl"
+      });
+      process.stdout.write(filtered);
+    } else {
+      await output(result, { mode: structuredMode });
+    }
+    return;
+  }
+  const theme = createTheme();
+  const lines = [];
+  if (result.total === 0) {
+    lines.push(theme.muted("No documentation entries found."));
+    await output(lines, { mode: "human" });
+    return;
+  }
+  lines.push("");
+  lines.push(`Documentation Entries (${result.total})`);
+  lines.push("=".repeat(60));
+  lines.push("");
+  for (const entry of result.entries) {
+    const pkg = entry.package ? theme.muted(` [${entry.package}]`) : "";
+    const kind = theme.muted(`(${entry.kind})`);
+    lines.push(`  ${entry.id} ${kind}${pkg}`);
+    lines.push(`    ${entry.title}`);
+    lines.push(`    ${theme.muted(entry.sourcePath)}`);
+    lines.push("");
+  }
+  await output(lines, { mode: "human" });
+}
+
+export { runDocsList, printDocsListResults };

package/dist/shared/outfitter-ypcvwg1s.js

@@ -0,0 +1,91 @@
+// @bun
+import {
+  __require
+} from "./outfitter-eepj7rf7.js";
+
+// apps/outfitter/src/manifest.ts
+import { join } from "path";
+import {
+  InternalError,
+  Result,
+  ValidationError
+} from "@outfitter/contracts";
+import { z } from "zod";
+var OUTFITTER_DIR = ".outfitter";
+var MANIFEST_FILE = "manifest.json";
+var BlockEntrySchema = z.object({
+  installedFrom: z.string(),
+  installedAt: z.string().datetime()
+});
+var ManifestSchema = z.object({
+  version: z.literal(1),
+  blocks: z.record(z.string(), BlockEntrySchema)
+});
+function manifestPath(cwd) {
+  return join(cwd, OUTFITTER_DIR, MANIFEST_FILE);
+}
+async function readManifest(cwd) {
+  const path = manifestPath(cwd);
+  const file = Bun.file(path);
+  if (!await file.exists()) {
+    return Result.ok(null);
+  }
+  let raw;
+  try {
+    raw = await file.text();
+  } catch {
+    return Result.err(InternalError.create("Failed to read manifest file", { path }));
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return Result.err(ValidationError.create("manifest", "Invalid JSON in manifest file"));
+  }
+  const validated = ManifestSchema.safeParse(parsed);
+  if (!validated.success) {
+    return Result.err(ValidationError.create("manifest", "Manifest file does not match expected schema"));
+  }
+  return Result.ok(validated.data);
+}
+async function writeManifest(cwd, manifest) {
+  const dirPath = join(cwd, OUTFITTER_DIR);
+  const path = join(dirPath, MANIFEST_FILE);
+  try {
+    const { mkdirSync, existsSync, statSync } = await import("fs");
+    if (existsSync(dirPath)) {
+      if (!statSync(dirPath).isDirectory()) {
+        return Result.err(ValidationError.create("manifest", ".outfitter exists but is not a directory"));
+      }
+    } else {
+      mkdirSync(dirPath, { recursive: true });
+    }
+    const content = JSON.stringify(manifest, null, "\t");
+    await Bun.write(path, `${content}
+`);
+    return Result.ok(undefined);
+  } catch {
+    return Result.err(InternalError.create("Failed to write manifest file", { path }));
+  }
+}
+async function stampBlock(cwd, blockName, toolingVersion) {
+  const readResult = await readManifest(cwd);
+  if (readResult.isErr()) {
+    return readResult;
+  }
+  const existing = readResult.value;
+  const manifest = existing ?? { version: 1, blocks: {} };
+  const updated = {
+    ...manifest,
+    blocks: {
+      ...manifest.blocks,
+      [blockName]: {
+        installedFrom: toolingVersion,
+        installedAt: new Date().toISOString()
+      }
+    }
+  };
+  return writeManifest(cwd, updated);
+}
+
+export { BlockEntrySchema, ManifestSchema, readManifest, writeManifest, stampBlock };