npm - @noir-ai/create - Versions diffs - 1.2.0-beta.1 - Mend

@noir-ai/create 1.2.0-beta.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (16) hide show

package/LICENSE +21 -0
package/dist/index.d.ts +448 -0
package/dist/index.js +712 -0
package/dist/index.js.map +1 -0
package/package.json +59 -0
package/templates/claude-context-block.md.tmpl +1 -0
package/templates/claude-rules-block.md.tmpl +1 -0
package/templates/config.yml.tmpl +2 -0
package/templates/dockerignore.tmpl +1 -0
package/templates/gitignore.tmpl +4 -0
package/templates/mcp.http.json.tmpl +8 -0
package/templates/mcp.stdio.json.tmpl +12 -0
package/templates/noir.md.tmpl +5 -0
package/templates/npmignore.tmpl +1 -0
package/templates/prettierignore.tmpl +1 -0
package/templates/rules-seed.md.tmpl +34 -0

package/LICENSE ADDED Viewed

@@ -0,0 +1,21 @@
+MIT License
+Copyright (c) 2026 agaaaptr
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.ts ADDED Viewed

@@ -0,0 +1,448 @@
+import { HostId, HostAdapter } from '@noir-ai/adapters';
+import { ManagedBlock } from '@noir-ai/core';
+/**
+ * The three-mode writer — generalizes keystone-K's `writeManagedRegion` into
+ * the declarative dispatch the scaffold manifest drives. Each mode maps 1:1 to
+ * an artifact class in the spec §4.5 matrix:
+ *
+ *  - {@link regenerate}    — pure pointers (`.mcp.json`, `NOIR.md` brief, …).
+ *                           Always overwritten, atomically.
+ *  - {@link managedBlock}  — co-owned files (`CLAUDE.md` context/rules,
+ *                           `.gitignore` noir block, …). DELEGATES to
+ *                           keystone-K's `writeManagedRegion` so user content
+ *                           outside the markers is preserved byte-for-byte and
+ *                           re-runs are idempotent. Never duplicate the
+ *                           managed-region logic.
+ *  - {@link skipIfExists}  — user-owned seeds (`RULES.md`, `config.yml`,
+ *                           `project.id`). Write once; never clobber.
+ *
+ * The orchestrator (`scaffold.ts`) is the only intended caller; the per-mode
+ * functions are exported so the cli (S-T2) and tests can drive them directly
+ * when a one-off write is needed outside the manifest.
+ */
+type WriteMode = 'regenerate' | 'managedBlock' | 'skipIfExists';
+interface WriteOutcome {
+    /** The absolute path that was written. */
+    path: string;
+    mode: WriteMode;
+    /** true when bytes hit disk; false for skipIfExists no-ops. regenerate and
+     *  managedBlock always write (managedBlock may write identical bytes — that
+     *  still counts as a write for telemetry purposes; the file IS up to date). */
+    written: boolean;
+}
+/** Atomic overwrite. Writes to `<file>.tmp.<pid>.<rnd>` in the same directory,
+ *  fsyncs, then renames over the target so a crash never leaves a half-written
+ *  file (the pointer files this is used for are read by the host agent first —
+ *  a truncated CLAUDE.md/.mcp.json would break the very startup Noir serves).
+ *
+ *  Parent directories are NOT created here — the orchestrator does that once
+ *  for the whole manifest so a missing dir is a single, attributable failure
+ *  rather than N silent ones inside the writer. */
+declare function regenerate(absPath: string, content: string): WriteOutcome;
+/** Re-emit a managed region, delegating to keystone-K's `writeManagedRegion`.
+ *  `regionText` MUST already include the begin/end markers (matches the shape
+ *  `writeManagedRegion` expects and that `IGNORE_BLOCK`/`CONTEXT_BLOCK`
+ *  callers build in core/cli). Use {@link buildRegion} to assemble it from a
+ *  block + body. */
+declare function managedBlock(absPath: string, block: ManagedBlock, regionText: string): WriteOutcome;
+/** Assemble `<begin>\n<body>\n<end>\n` for a managed block. Centralized here so
+ *  every caller (manifest rendering, tests, future migrations) produces the
+ *  exact byte shape `writeManagedRegion` strips/expects. The trailing newline
+ *  is part of the contract — `stripManagedBlock`'s regex eats a trailing `\n`
+ *  so re-runs stay idempotent instead of accumulating blank lines.
+ *
+ *  `body` is `trimEnd()`-ed before wrapping so template authors can keep the
+ *  conventional trailing newline in `.tmpl` files without producing a
+ *  double-newline before the end marker. This keeps the output byte-identical
+ *  to `claudeAdapter.emitContext`/`emitRules` and core's `syncIgnores`, which
+ *  S-T2 relies on for a diff-free refactor. */
+declare function buildRegion(block: ManagedBlock, body: string): string;
+/** Write `content` to `absPath` only if no file exists there. Returns whether
+ *  bytes were written. Parent dirs are NOT created (orchestrator's job). */
+declare function skipIfExists(absPath: string, content: string): WriteOutcome;
+/**
+ * Declarative scaffold manifest — the single source of truth for what
+ * `init` / `create` / `sync` emit. Each entry is one artifact, tagged with its
+ * write {@link WriteMode} so the orchestrator can dispatch without knowing
+ * what's inside.
+ *
+ * FAITHFULNESS CONTRACT (S-T1 → S-T2 → S10): this table is a strict superset of
+ * the artifacts `packages/cli/src/{init,sync}.ts` wrote pre-Slice-S. The cli
+ * refactor (S-T2) replaced those ad-hoc writers with a call into `scaffold()`;
+ * the byte-for-byte output MUST stay equivalent for first-run init. S10 makes
+ * the manifest HOST-PARAMETRIC: {@link buildManifest} now returns host-agnostic
+ * entries + a {@link buildHostArtifacts} call that materializes per-host files
+ * (CLAUDE.md/GEMINI.md for claude/gemini; AGENTS.md + .cursor/.../opencode.json
+ * for agents-md/cursor/opencode) via the resolved adapter. The claude default
+ * `noir init` stays BYTE-IDENTICAL to v1.1 — fix-wave I1 REMOVED the additive
+ * root `AGENTS.md` (it was double-importing `.noir/NOIR.md` + RULES.md via
+ * CLAUDE.md's existing @-imports; claude's native surface is CLAUDE.md alone).
+ *
+ * Path-derivation: repo-relative POSIX strings that mirror
+ * `@noir-ai/core/layout.ts` (`paths.*`). The test suite asserts
+ * `join(root, entry.path) === paths.X(root)` for every entry layout knows
+ * about, so a layout rename is caught here instead of silently drifting.
+ */
+/** S10: `HostTag` is now the SAME `HostId` enum the adapter registry uses
+ *  (re-exported so existing imports keep working). Pre-S10 this was the
+ *  literal `'claude'`; widening to `HostId` lets one manifest serve every host
+ *  via the orchestrator's host filter + {@link buildHostArtifacts}. */
+type HostTag = HostId;
+interface ManifestEntry {
+    /** Repo-relative POSIX path (forward slashes). Orchestrator joins with root. */
+    path: string;
+    mode: WriteMode;
+    /** Host tag; entry is skipped when opts.host !== entry.host.
+     *  Undefined = host-agnostic (every host emits it). */
+    host?: HostTag;
+    /** Required for `managedBlock` mode: the named block to re-emit. */
+    block?: ManagedBlock;
+    /** Literal content (`regenerate`/`skipIfExists`) or literal region BODY
+     *  (`managedBlock` — the orchestrator wraps it with the block markers).
+     *  Mutually exclusive with {@link template}. */
+    content?: string;
+    /** Template name (resolved by `template-loader`) for content/body.
+     *  Mutually exclusive with {@link content}. */
+    template?: string;
+    /** One-line human description for `noir doctor` + logs. */
+    description?: string;
+}
+type BuildManifestContext = {
+    /** Absolute repo root. Added in S10 so {@link buildHostArtifacts} can resolve
+     *  absolute adapter paths (`adapter.mcpConfigPath({root})`, etc.) to the
+     *  manifest's repo-relative POSIX shape. */
+    root: string;
+    /** Canonical project id (already created/read by the orchestrator). */
+    projectId: string;
+    /** Target host. Drives {@link buildHostArtifacts} via `resolveAdapter(host)`. */
+    host: HostTag;
+    /** MCP transport the host should use to reach Noir. */
+    transport: 'stdio' | 'streamable-http';
+    /** Required when transport is `streamable-http`. */
+    url?: string;
+};
+/** Co-owned NOIR.md auto-brief region. Defined locally (not exported from
+ *  core) because core's keystone-K named instances cover only the three
+ *  regions core itself writes (context/rules/ignore); the brief is the
+ *  scaffold engine's own. Uses the SAME `managedBlock()` factory so marker
+ *  shape stays consistent with the rest of the family. */
+declare const BRIEF_BLOCK: ManagedBlock;
+declare const MANIFEST_PATH_PARITY: ReadonlyArray<[
+    entryPath: string,
+    layoutFn: (root: string) => string
+]>;
+/**
+ * Build the manifest for a given ctx. Pure (no I/O). The orchestrator calls
+ * this once per scaffold run; tests assert the shape is stable.
+ *
+ * S10 structure: the manifest is now `[...hostAgnosticEntries(ctx), ...hostSpecificEntries(ctx)]`
+ * where the host-specific half comes from {@link buildHostArtifacts} (driven by
+ * `resolveAdapter(ctx.host)`). The host-agnostic half is unchanged from v1.1
+ * (canonical `.noir/` store + ignore files). Fix-wave I1: {@link buildHostArtifacts}
+ * emits AGENTS.md ONLY for agents-md/cursor/opencode (claude/gemini use their
+ * own CLAUDE.md/GEMINI.md — emitting AGENTS.md too would double-import .noir/).
+ *
+ * Mode-tagging rationale per artifact (see S-T1 report for the full table):
+ *  - `project.id`  → skipIfExists. First init writes a fresh id; re-init MUST
+ *    NOT overwrite — that would orphan the indexed store DB named after it.
+ *  - `config.yml`  → skipIfExists. User-owned; the seed is written once.
+ *    (The seed renders `host: {{host}}` so a `--host gemini` init persists the
+ *    chosen host for `noir sync` to read back.)
+ *  - `NOIR.md`     → managedBlock (BRIEF_BLOCK). Auto-brief is co-owned.
+ *  - `RULES.md`    → skipIfExists. User-owned working-contract seed.
+ *  - ignore files  → managedBlock (IGNORE_BLOCK). Matches syncIgnores.
+ *  - host entries  → SEE {@link buildHostArtifacts} (regenerate / managedBlock).
+ */
+declare function buildManifest(ctx: BuildManifestContext): ManifestEntry[];
+/** Context shape passed to {@link buildHostArtifacts}. A strict subset of
+ *  {@link BuildManifestContext} (no `projectId`/`host` — the adapter IS the
+ *  resolved host, and host artifacts never need the project id). Exported
+ *  separately so callers + tests can name the narrower contract. */
+interface BuildHostArtifactsContext {
+    root: string;
+    transport: 'stdio' | 'streamable-http';
+    url?: string;
+}
+/**
+ * Materialize the host-specific manifest entries from a resolved adapter.
+ * SINGLE entry point — no scattered `if (host === '…')` conditionals in the
+ * orchestrator. Returns entries in emission order:
+ *
+ *   1. **AGENTS.md** (universal baseline) — `regenerate` at
+ *      `adapter.agentsMdPath(ctx)` (default `<root>/AGENTS.md`), content from
+ *      the shared `emitAgentsMd(ctx)` helper. Emitted ONLY for hosts whose
+ *      `emitContext` IS the AGENTS.md content (agents-md, cursor, opencode) —
+ *      for them AGENTS.md is the SINGLE native context surface AND carries the
+ *      Noir working rules via its `@.noir/rules/RULES.md` import. claude and
+ *      gemini have their OWN native context file (CLAUDE.md / GEMINI.md) that
+ *      `@`-imports the canonical `.noir/` sources; emitting AGENTS.md too
+ *      would IMPORT THOSE FILES TWICE into the host's context (2× tokens +
+ *      drift risk), so for those two hosts AGENTS.md is SKIPPED. (Claude Code
+ *      still discovers AGENTS.md at the repo root when present — users who
+ *      want the universal file can drop one in by hand; Noir's auto-emission
+ *      stays single-source per host.)
+ *   2. **Host-native context file** — emitted ONLY for hosts whose `emitContext`
+ *      is NOT the AGENTS.md content (i.e. the host has its OWN context file
+ *      with a distinct syntax). Concretely: claude → `CLAUDE.md` (CONTEXT +
+ *      RULES managed blocks, byte-identical to v1.1 via templates); gemini →
+ *      `GEMINI.md` (CONTEXT + RULES managed blocks with Gemini's bare `@`
+ *      import syntax). For `agents-md`/`cursor`/`opencode` the context IS the
+ *      AGENTS.md (already emitted in step 1) → SKIP to avoid a duplicate.
+ *      Rules live INSIDE the host's context file: claude's in CLAUDE.md,
+ *      gemini's in GEMINI.md, agents-md/cursor/opencode's in AGENTS.md — NO
+ *      host emits a separate rules file. (The prior cursor
+ *      `.cursor/rules/noir-contract.mdc` host-rules pointer was REMOVED: it
+ *      collided with the C3 cursor flat-skill prune of `noir-*.mdc` under
+ *      `.cursor/rules/`, and cursor's rules are already delivered via
+ *      AGENTS.md's `@.noir/rules/RULES.md` import.)
+ *   3. **Host MCP config** — `regenerate` at `adapter.mcpConfigPath(ctx)`
+ *      (default `<root>/.mcp.json` for claude), content from
+ *      `adapter.emitMcpConfig(ctx, {transport,url})`. Claude KEEPS the template
+ *      path (byte-identical parity with v1.1 + the .mcp.json parity test that
+ *      compares against `claudeAdapter.emitMcpConfig`); other hosts use the
+ *      adapter directly.
+ *
+ * Skills are OUT OF SCOPE here — the cli composes `emitSkillsToDir` with
+ * `adapter.skillsDir` + the host's `CompileTarget` (claude → `.claude/skills/`
+ * as SKILL.md; cursor → `.cursor/rules/<skill>.mdc` FLAT per C3; gemini/
+ * agents-md/opencode have no skill dir → skip).
+ */
+declare function buildHostArtifacts(adapter: HostAdapter, ctx: BuildHostArtifactsContext): ManifestEntry[];
+/**
+ * Migration model — Nx-style declarative upgrade scripts, hand-rolled.
+ *
+ * Per the Slice S design (S-OQ2 resolved → inline conflict markers, never
+ * interactive prompts), every migration script:
+ *  - is a small, IDEMPOTENT TypeScript function (`run(root, opts) → result`).
+ *    Re-running it on an already-migrated tree is a no-op (or produces the
+ *    same conflict markers again — also safe).
+ *  - NEVER prompts. `--no-input` CI must survive. When a migration cannot
+ *    reconcile a co-edited region, it writes git-style conflict markers
+ *    (`<<<<<<<` / `=======` / `>>>>>>>`) into the file and records the path in
+ *    `result.conflicts` so the caller (doctor/CI) can fail loudly with a
+ *    reviewable artifact rather than hang on a prompt.
+ *
+ * The registry ({@link MIGRATIONS}) is the deliverable at v1.0.0 — there are no
+ * real version-to-version migrations yet. The synthetic `1.0.0 → 1.0.0`
+ * migration exists to exercise the runner end-to-end and to give a template
+ * for the first real migration.
+ */
+interface MigrationContext {
+    /** Absolute repo root the migration operates on. */
+    root: string;
+    /** When true, the runner performs all reads and the would-be writes, returns
+     *  the same `changed`/`conflicts` shape, but does NOT touch disk. Used by
+     *  `noir doctor`/CI to preview. */
+    dryRun?: boolean;
+}
+interface MigrationResult {
+    /** Repo-relative paths the migration modified (or would modify, in dryRun). */
+    changed: string[];
+    /** Repo-relative paths left with inline conflict markers. Always non-throwing. */
+    conflicts: string[];
+    /** Free-form notes for doctor/CI logs (e.g. "rewrote CLAUDE.md import"). */
+    notes: string[];
+}
+/** A single version-to-version step. `from`/`to` are inclusive endpoints on a
+ *  linear history; the runner composes a chain by matching `from` of the next
+ *  script to `to` of the previous. */
+interface MigrationScript {
+    from: string;
+    to: string;
+    description: string;
+    run: (ctx: MigrationContext) => MigrationResult;
+}
+/**
+ * Migration runner. Given a `from` version present on disk and a target `to`
+ * version (usually {@link CURRENT_SCAFFOLD_VERSION}), walks the
+ * {@link MIGRATIONS} registry forward in version order, executing each step.
+ *
+ * Selection rule: a script runs when its `from` is `>= fromArg` (semver-ish
+ * string compare is enough at Noir's scale; we don't pull in a semver dep for
+ * this) AND its `to` is `<= toArg`. Scripts strictly outside the window are
+ * skipped. Within the window, scripts run sorted by `to` ascending so a
+ * multi-step upgrade (1.0.0 → 1.1.0 → 1.2.0) composes in order.
+ *
+ * The runner NEVER throws on a per-script failure — it captures the error,
+ * records a synthetic conflict entry (`<path>__error`), and continues so a
+ * single broken migration doesn't block the rest of the chain. The orchestrator
+ * decides whether non-empty `conflicts` is a hard failure (init --upgrade) or a
+ * warning (doctor).
+ *
+ * Returns the aggregate of every step's `changed`/`conflicts`/`notes`.
+ */
+declare function runMigrations(root: string, from: string | null, to: string, opts?: {
+    dryRun?: boolean;
+}): MigrationResult & {
+    from: string | null;
+    to: string;
+    ran: string[];
+};
+declare const MIGRATIONS: readonly MigrationScript[];
+/** Write git-style inline conflict markers around `theirs`/`ours` so a human
+ *  or AI agent can resolve later. This is the CI-safe fallback the spec locks
+ *  in (S-OQ2) — no interactive prompts, ever. */
+declare function applyInlineConflict(ours: string, theirs: string, oursLabel?: string, theirsLabel?: string): string;
+/** Apply `(ours, theirs)` to a region: if they're equal, return `ours` (no
+ *  conflict); otherwise emit inline markers. Migration authors should prefer
+ *  this over {@link applyInlineConflict} when the "no change needed" case is
+ *  common — it keeps re-runs truly idempotent (no spurious markers on a clean
+ *  tree). */
+declare function applyWithConflict(ours: string, theirs: string, path: string): {
+    text: string;
+    conflicted: boolean;
+};
+/**
+ * READ-ONLY stack detection. Probes for well-known marker files under `root`
+ * and reports ONLY what is present — never assumes. The result feeds path
+ * adaptation (where to drop `.claude/` vs `.cursor/` etc., future), ignore-file
+ * selection, and the onboarding TUI's confirm step.
+ *
+ * Design rules (spec §4.5):
+ *  - Never throws. A foreign/empty dir returns `{ languages: [], monorepo:
+ *    false, frameworks: [], packageManager: null }`.
+ *  - Never opens network, never parses code beyond a `package.json`/`pyproject`
+ *    dependency list. Marker files + top-level manifests only.
+ *  - Frameworks are reported only when both the marker file is present AND the
+ *    framework's dependency is listed (avoids false positives from a stale
+ *    `package.json`).
+ */
+interface StackInfo {
+    /** Lower-cased language ids found via marker files:
+     *  `typescript` | `javascript` | `python` | `go` | `rust`. */
+    languages: string[];
+    /** True when a workspace manifest is present (pnpm-workspace, npm/yarn
+     *  workspaces in package.json, turbo.json, nx.json). */
+    monorepo: boolean;
+    /** Lower-cased framework ids (e.g. `next`, `vite`, `express`, `fastapi`,
+     *  `actix`). Empty when none detected. */
+    frameworks: string[];
+    /** `pnpm` | `npm` | `yarn` when a lockfile is present, else null. */
+    packageManager: string | null;
+}
+declare function detectStack(root: string): StackInfo;
+/**
+ * Scaffold orchestrator. One function the cli (S-T2) calls for `noir init`,
+ * `noir create`, and `noir sync`; mode selects the manifest subset + how
+ * project identity is resolved.
+ *
+ * High-level flow:
+ *  1. Resolve project id (provided > existing > generated; sync requires existing).
+ *  2. Detect stack (READ-ONLY; always runs; never throws).
+ *  3. If {@link ScaffoldOptions.upgrade}, run migrations from the on-disk
+ *     scaffold-version → {@link CURRENT_SCAFFOLD_VERSION}.
+ *  4. Build the manifest, filter by host + mode.
+ *  5. For each entry: mkdir -p, render template/content, dispatch to the
+ *     matching writer.
+ *  6. On `init`/`create`, stamp `.noir/scaffold-version` LAST so a crash leaves
+ *     an old/absent stamp rather than a misleading fresh one.
+ *
+ * The orchestrator owns dir creation (writers refuse to so that a missing dir
+ * is one attributable failure, not N silent ones).
+ */
+type ScaffoldMode = 'init' | 'create' | 'sync';
+interface ScaffoldOptions {
+    /** Absolute repo root. For `create`, the new dir (created if absent). */
+    root: string;
+    mode: ScaffoldMode;
+    /** Target host. Defaults to `'claude'` (the only shipped host). */
+    host?: HostTag;
+    /** MCP transport. Defaults to `'stdio'`. */
+    transport?: 'stdio' | 'streamable-http';
+    /** Required when transport is `streamable-http`. */
+    url?: string;
+    /** Explicit project id; bypasses generate/read. Mainly for tests + `create`
+     *  flows that want deterministic ids. */
+    projectId?: string;
+    /** `noir init --upgrade`: run migrations before re-emitting, and emit only
+     *    regenerate + managedBlock (skipIfExists left alone). Only meaningful
+     *    with mode `'init'`. */
+    upgrade?: boolean;
+    /** Preview: compute the same written/skipped/migrated lists without touching
+     *    disk. `noir doctor`/CI use this to report drift. */
+    dryRun?: boolean;
+}
+interface ScaffoldResult {
+    /** Repo-relative paths actually written. */
+    written: string[];
+    /** Repo-relative paths skipIfExists'd (already present). */
+    skipped: string[];
+    /** Migration steps executed (`<from>→<to>`), when upgrade ran. */
+    migrationsRan: string[];
+    /** Migration conflicts (repo-relative or `<runner>:…`), when upgrade ran. */
+    migrationConflicts: string[];
+    stack: StackInfo;
+    projectId: string;
+    fromVersion: string | null;
+    toVersion: string;
+    /** The host actually emitted (post-default). */
+    host: HostTag;
+}
+declare function scaffold(opts: ScaffoldOptions): Promise<ScaffoldResult>;
+/**
+ * Scaffold version stamp — Noir's equivalent of Copier's `last-applied`.
+ * Stored at `.noir/scaffold-version` as a single `noir-scaffold=<semver>` line
+ * so `noir init --upgrade` / `noir doctor` can diff against
+ * {@link CURRENT_SCAFFOLD_VERSION} and decide which migrations to run.
+ *
+ * Format is line-oriented (not YAML) on purpose: it must be readable before
+ * `config.yml` is parsed (doctor runs even with a broken config), and the
+ * `key=value` shape is trivial to grep from a shell.
+ */
+/** The scaffold version this build of @noir-ai/create ships. Bumped atomically
+ *  whenever a manifest entry, template, or migration changes shape. */
+declare const CURRENT_SCAFFOLD_VERSION = "1.0.0";
+/** Path to the stamp file under `root`. Exposed for tests + doctor. */
+declare function scaffoldVersionPath(root: string): string;
+/** Read the applied scaffold version, or `null` if the stamp is absent/unparseable.
+ *  Never throws — doctor must keep reporting even on a malformed stamp. */
+declare function readScaffoldVersion(root: string): string | null;
+/** Write the stamp, creating `.noir/` if needed. The orchestrator writes it
+ *  LAST so a crash mid-scaffold leaves an old/absent stamp rather than a
+ *  misleading fresh one.
+ *
+ *  N2: routed through the package's atomic `regenerate()` writer (tmp+rename in
+ *  the same dir) for consistency with the rest of the engine's durable writes —
+ *  a half-written stamp would mislead `noir doctor`/`init --upgrade`, so the
+ *  stamp deserves the same crash-atomicity as `.mcp.json` and the NOIR.md brief. */
+declare function writeScaffoldVersion(root: string, version: string): void;
+/**
+ * Hand-rolled `{{var}}` interpolation. No mustache/handlebars dependency —
+ * Noir's markdown/yaml/json templates are simple enough that a tokenizer +
+ * map lookup is sufficient and keeps `@noir-ai/create` dependency-light.
+ *
+ * Semantics (documented):
+ *  - Tokens are `{{ name }}` / `{{name}}` — any amount of ASCII whitespace
+ *    inside the braces is permitted. The name is trimmed.
+ *  - Known vars (value is a string) are substituted verbatim. NO escaping is
+ *    applied — callers must pre-escape for the target format (JSON/YAML/MD).
+ *    This is intentional: the engine renders into multiple formats and a
+ *    single universal escaper would be wrong for at least one of them.
+ *  - Unknown vars (not in `vars`, or value `undefined`) → the original token
+ *    is LEFT IN PLACE. Rationale: drift between template and ctx becomes
+ *    visible (an unrendered `{{projectId}}` in CLAUDE.md is immediately
+ *    obvious), rather than silently swallowed to empty. The spec called this
+ *    out as the preferred failure mode.
+ *  - Non-string var values are stringified via `String(value)` so a stray
+ *    number/boolean still interpolates rather than printing `[object Object]`.
+ *  - A lone `{{` with no closing `}}` is left untouched (not a token).
+ */
+declare function render(template: string, vars: Record<string, unknown>): string;
+/** Read a template's raw text by name (e.g. `noir.md.tmpl`). Throws on missing
+ *  — an unknown template is a manifest bug and should fail loudly, not render
+ *  an empty string silently. */
+declare function loadTemplate(name: string): string;
+/** Resolve a template name to its absolute path (for diagnostics + tests). */
+declare function templatesDir(): string;
+export { BRIEF_BLOCK, type BuildHostArtifactsContext, type BuildManifestContext, CURRENT_SCAFFOLD_VERSION, type HostTag, MANIFEST_PATH_PARITY, MIGRATIONS, type ManifestEntry, type MigrationContext, type MigrationResult, type MigrationScript, type ScaffoldMode, type ScaffoldOptions, type ScaffoldResult, type StackInfo, type WriteMode, type WriteOutcome, applyInlineConflict, applyWithConflict, buildHostArtifacts, buildManifest, buildRegion, detectStack, loadTemplate, managedBlock, readScaffoldVersion, regenerate, render, runMigrations, scaffold, scaffoldVersionPath, skipIfExists, templatesDir, writeScaffoldVersion };