@mannyc1/ts-release 0.0.0

package/README.md

@@ -0,0 +1,249 @@
+# release
+
+`@mannyc1/ts-release` turns release intent into explicit, inspectable, repeatable publishing operations.
+
+The default workflow is plan-first:
+
+```sh
+bun run cli plan --config release.config.json --format text
+bun run cli render --config release.config.json --execute
+bun run cli validate --config release.config.json
+bun run cli print --config release.config.json
+bun run cli execute --config release.config.json --execute --approve-irreversible
+bun run cli verify --config release.config.json
+```
+
+Rendering writes generated target files locally and records `render.json` evidence. Publishing is blocked unless execution is explicitly approved. Irreversible operations require a second approval flag.
+
+## Imports
+
+The package intentionally avoids aggregate library barrels. The root `release` export is intentionally empty; import the exact module you need from an explicit subpath.
+
+```ts
+import * as Effect from "effect/Effect"
+import * as Layer from "effect/Layer"
+import { type ReleaseIntent } from "@mannyc1/ts-release/domain/release"
+import { BunReleaseHostLayer } from "@mannyc1/ts-release/host/bun"
+import { createReleasePlan } from "@mannyc1/ts-release/planner/create-release-plan"
+import { validatePlan } from "@mannyc1/ts-release/planner/executor"
+import { LiveTargetRegistryLayer } from "@mannyc1/ts-release/targets/live"
+
+const planAndValidate = (intent: ReleaseIntent) =>
+  Effect.gen(function*() {
+    const plan = yield* createReleasePlan(intent)
+    const evidence = yield* validatePlan(plan)
+    return { plan, evidence }
+  }).pipe(
+    Effect.provide(Layer.mergeAll(BunReleaseHostLayer, LiveTargetRegistryLayer))
+  )
+```
+
+`createReleasePlan` needs a `TargetRegistry` layer. Workflows that read files, run commands, or write evidence also need a `ReleaseHost` layer. Internal Effect imports use deep module paths such as `effect/Effect` and `effect/Layer` to keep bundlers from depending on broad root-package analysis.
+
+## Programmatic CLI
+
+Applications can run the CLI command path without spawning the executable:
+
+```ts
+import * as Effect from "effect/Effect"
+import {
+  PlanReleaseConfigOptions,
+  planReleaseConfig,
+  ReleaseCliOptions,
+  runReleaseCli
+} from "@mannyc1/ts-release/cli/programmatic"
+
+await Effect.runPromise(
+  runReleaseCli([
+    "plan",
+    "--config",
+    "release.config.json",
+    "--format",
+    "text"
+  ], ReleaseCliOptions.make({ root: "/path/to/release-workspace" }))
+)
+
+const plan = await Effect.runPromise(
+  planReleaseConfig(
+    PlanReleaseConfigOptions.make({
+      root: "/path/to/release-workspace",
+      configPath: "release.config.json"
+    })
+  )
+)
+```
+
+The helper provides the Bun host and live target registry internally, so callers do not need to import `effect/unstable/cli/Command` or assemble CLI layers by hand.
+
+## Example Config
+
+```json
+{
+  "identity": {
+    "name": "@mannyc1/ts-release",
+    "version": "0.1.0",
+    "commit": "abc123",
+    "tag": "v0.1.0",
+    "notes": "Release notes"
+  },
+  "artifacts": [
+    {
+      "id": "package",
+      "path": ".",
+      "format": "directory",
+      "consumers": ["npm"]
+    },
+    {
+      "id": "github-asset",
+      "path": "artifacts/mannyc1-ts-release-0.1.0.tgz",
+      "format": "tarball",
+      "consumers": ["github"]
+    }
+  ],
+  "targets": [
+    {
+      "_tag": "NpmRegistryTarget",
+      "id": "npm",
+      "registry": "https://registry.npmjs.org",
+      "packagePath": ".",
+      "tokenEnv": "NPM_TOKEN",
+      "access": "public",
+      "provenance": true,
+      "dryRunSupport": "native",
+      "mutability": "immutable",
+      "recovery": "publish-new-version"
+    },
+    {
+      "_tag": "GitHubReleaseTarget",
+      "id": "github",
+      "repository": "owner/repo",
+      "draft": true,
+      "dryRunSupport": "native",
+      "mutability": "mutable-release",
+      "recovery": "delete-and-recreate"
+    }
+  ],
+  "strict": true,
+  "evidenceDirectory": ".release/evidence"
+}
+```
+
+Paths are release-workspace relative and may not be absolute or contain parent traversal.
+
+Homebrew tap targets model catalog updates as generated files plus an approval-gated push:
+
+```json
+{
+  "_tag": "HomebrewTapTarget",
+  "id": "homebrew",
+  "repository": "owner/homebrew-tap",
+  "formulaName": "release",
+  "formulaPath": ".release/generated/release.rb",
+  "artifactId": "github-asset",
+  "url": "https://github.com/owner/repo/releases/download/v0.1.0/mannyc1-ts-release-0.1.0.tgz",
+  "installPath": "bin/release",
+  "dryRunSupport": "simulated",
+  "mutability": "mutable-index",
+  "recovery": "manual"
+}
+```
+
+Use `plan`, `render --execute`, `validate`, `print`, `execute --execute`, and `verify` so generated formulas are reviewable before any tap update is pushed.
+
+## Plan Review
+
+Text plans include the release identity, evidence directory, artifact inventory, target capabilities, operation commands, validation notes, and execution gates.
+
+```text
+@mannyc1/ts-release@0.1.0
+commit: abc123
+evidence: .release/evidence
+artifacts: 2
+targets: 2
+operations: 13
+
+targets:
+  - github [GitHubReleaseTarget] auth=cli-auth dry-run=native strategy=simulated-plan mutability=mutable-release recovery=delete-and-recreate
+  - npm [NpmRegistryTarget] auth=env-token dry-run=native strategy=native-command mutability=immutable recovery=publish-new-version
+```
+
+JSON plans include the same data in a stable, CI-artifact-friendly shape, including `targetCapabilities`.
+
+GitHub release verification checks the release tag, title, draft flag, prerelease flag, and each uploaded artifact name.
+
+## Public API
+
+The intentional public API is the explicit subpath list in `package.json`. `release/cli` and `release/cli/command` are public so applications can embed the CLI command, while the executable remains available through the `release` binary.
+
+The package export checker fails if a new export is added without being added to the intentional API list.
+
+## Examples
+
+Runnable example configs live in `examples/`:
+
+- `examples/npm-only`
+- `examples/github-release`
+- `examples/homebrew-tap`
+- `examples/non-strict-skips`
+
+Build the package first, then plan an example from its directory:
+
+```sh
+bun run build
+cd examples/github-release
+bun ../../dist/cli/main.js plan --config release.config.json --format text
+```
+
+## Evidence
+
+Validation and execution evidence is written as JSON bundles. Failed commands still preserve partial evidence before the command failure is returned.
+
+```json
+{
+  "schemaVersion": "release-evidence/v1",
+  "releaseName": "release",
+  "releaseVersion": "0.1.0",
+  "records": [
+    {
+      "id": "npm:npm-pack-dry-run:command",
+      "operationId": "npm:npm-pack-dry-run",
+      "status": "passed",
+      "severity": "info",
+      "exitCode": 0
+    }
+  ]
+}
+```
+
+Non-strict mode records missing validators as visible skipped evidence instead of silently dropping them.
+
+## Readiness
+
+Normal verification stays deterministic and does not require live external services:
+
+```sh
+bun run check:release
+```
+
+CI runs the portable package checks on Linux, macOS, and Windows. The Ubuntu release-readiness lane also runs the self-release config guard.
+
+Real-tool integration checks are opt-in:
+
+```sh
+bun run test:integration:tools
+RELEASE_INTEGRATION_GITHUB=1 bun run test:integration:tools
+```
+
+The first command validates npm adapter operations against the real `npm` CLI. The second also validates GitHub adapter readiness checks against the real `gh` CLI and requires `gh auth status` to succeed.
+
+Example configs are checked through the same programmatic CLI command path:
+
+```sh
+bun run check:examples
+```
+
+This repository also includes a first release config at `release.config.json` that targets both npm and GitHub for the scoped `@mannyc1/ts-release` package. The self-release config must pass `bun run check:self-release-config` before release checks proceed. Its `identity.commit` may be the explicit current short commit, or `HEAD` to mean the current committed checkout for a stored self-release config. The local first-release config uses a local `NPM_TOKEN` for npm and GitHub CLI authentication for GitHub; enable npm provenance for CI-based publishes where the registry can generate provenance.
+
+```sh
+bun run check:self-release-config
+```

package/SPEC.md

@@ -0,0 +1,254 @@
+# Release Package Spec
+
+## Purpose
+
+The `release` package is a small TypeScript library for turning release intent into explicit, inspectable, and repeatable publishing operations.
+
+It should not be a build system, a package-manager wrapper, or a generic task runner. Its job is to model what is being released, where it is being published, what must be true before publication, and which irreversible actions require deliberate approval.
+
+The package should make release work boring: the same inputs should produce the same plan, the same validations should produce auditable evidence, and the same publish operation should be understandable before anything is executed.
+
+## Core Idea
+
+A release is a data flow:
+
+```text
+release intent
+  -> normalized release model
+  -> target-specific operations
+  -> validation evidence
+  -> gated execution
+  -> post-publish verification
+```
+
+The package owns the model and the orchestration. Ecosystem tools remain the source of truth for ecosystem-specific behavior.
+
+For example, npm, PyPI, GitHub Releases, Homebrew taps, OCI registries, app stores, or other targets may each need different commands, credentials, artifacts, and validators. The release package should describe those differences directly instead of hiding them behind one fake universal publish abstraction.
+
+## Design Goals
+
+### Plan-first
+
+The primary output of the package is a release plan, not a side effect.
+
+A plan should be serializable, reviewable, and suitable for CI artifacts. It should explain:
+
+- release identity: name, version, commit, tag, notes, and source metadata
+- artifact inventory: files, checksums, sizes, formats, and intended consumers
+- target operations: what each target will do and what inputs it needs
+- validation steps: which checks must run before publishing
+- execution gates: which operations are irreversible or require explicit approval
+- evidence paths: where validation and publish results will be recorded
+
+### Explicit target semantics
+
+Different distribution targets have different shapes. The package should model those shapes instead of flattening them.
+
+Examples:
+
+- A release host publish creates or updates a release record and uploads assets.
+- A registry publish creates immutable package versions.
+- A catalog update changes a repository or index that points at artifacts.
+- A deployment promotes already-built assets into an environment.
+
+Each target should declare its required inputs, auth requirements, dry-run support, validation strategy, mutability rules, and recovery behavior.
+
+### Evidence-driven validation
+
+Validation should produce structured evidence, not just console output.
+
+Evidence should be machine-readable enough for CI and human-readable enough for debugging. It should include command invocations, tool versions where practical, exit statuses, important paths, skipped checks, warnings, failures, and timestamps.
+
+Strict mode should fail on missing required validators. Non-strict mode may record skips, but skips must be visible in the evidence.
+
+### Gated irreversible actions
+
+Operations that publish immutable versions, create public releases, overwrite indexes, or otherwise affect users must be marked as irreversible or externally visible.
+
+The default behavior should be dry-run or print-only. Execution should require an explicit execute flag, and irreversible operations should require a second confirmation flag or equivalent programmatic approval.
+
+The package should make it hard to accidentally publish and easy to see exactly what would be published.
+
+### Library-first, CLI-second
+
+The core package should be a reusable library. A CLI can exist as an adapter, but it should not contain the release logic.
+
+The library should expose APIs for:
+
+- loading and normalizing config
+- constructing a release plan
+- rendering target files or generated metadata
+- validating plans and artifacts
+- preparing executable operations
+- running approved operations through an injected host interface
+- recording evidence
+
+The CLI should mainly parse arguments, call the library, and format output.
+
+### Host abstraction without pretending the world is pure
+
+The package should isolate filesystem, environment, process execution, network calls, and time behind a narrow host interface where that improves testability and portability.
+
+The host boundary should not become a full application framework. It exists so core planning logic can be deterministic and so execution can be tested without touching real registries or release hosts.
+
+### Composable, not magical
+
+The package should compose with existing tools rather than replace them.
+
+Builders, packagers, changelog generators, signing tools, registry CLIs, provenance tools, and ecosystem validators should be treated as inputs or adapters. The release package should coordinate them, capture their evidence, and enforce release policy around them.
+
+## Non-goals
+
+The package should not try to:
+
+- build every artifact itself
+- replace ecosystem-native publishing tools
+- invent a universal package format
+- hide target-specific auth requirements
+- guarantee semantic versioning policy for the project using it
+- own changelog generation as a core requirement
+- require a monorepo
+- require a specific CI provider
+- treat dry-run output as equivalent to successful publication
+
+These may be integrated through adapters, but they should not define the core.
+
+## Core Concepts
+
+### Release Intent
+
+User-authored input describing what should be released.
+
+It should be concise but complete enough to identify the release, locate artifacts, choose targets, and declare policy.
+
+### Release Model
+
+A normalized internal representation with defaults resolved, paths normalized, targets expanded, and invalid combinations rejected.
+
+The model should be deterministic and independent of terminal formatting or CLI flags.
+
+### Release Plan
+
+A serializable plan derived from the release model.
+
+The plan is the contract between planning, validation, execution, and CI review. It should be stable enough to diff in tests and inspect in logs.
+
+### Target Adapter
+
+A module that knows how to plan, validate, and execute operations for one distribution target.
+
+Adapters should expose capabilities clearly: dry-run support, required credentials, validation commands, generated files, publish commands, and expected evidence.
+
+### Operation
+
+A concrete action that may be rendered, validated, executed, or skipped.
+
+Operations should carry enough metadata to explain their risk level, inputs, outputs, and execution requirements.
+
+### Evidence
+
+Structured records produced by validation, rendering, execution, and verification.
+
+Evidence should survive outside the process as JSON or another stable format. It should be useful for CI summaries, release audits, and debugging failed publishes.
+
+## Expected Public Surface
+
+The package should make these workflows straightforward:
+
+- create a plan from config
+- inspect the plan without executing anything
+- render target-specific files
+- validate artifacts and target readiness
+- produce evidence artifacts
+- print publish operations
+- execute approved operations
+- verify published state after execution
+
+The API should favor explicit functions and typed data over hidden global state.
+
+## Configuration Principles
+
+Configuration should be declarative and boring.
+
+It should describe release facts and target policy, not arbitrary scripts. Escape hatches can exist, but they should be visible in the plan and evidence.
+
+Good config answers:
+
+- What is the release?
+- Which artifacts are part of it?
+- Which targets receive it?
+- What credentials or environment are required?
+- What must be validated first?
+- Which generated files or indexes will change?
+- Which operations are allowed to execute in this environment?
+
+## Testing Strategy
+
+The core should be heavily testable without real external services.
+
+Important test categories:
+
+- config parsing and normalization
+- invalid config diagnostics
+- deterministic plan generation
+- adapter capability modeling
+- dry-run behavior
+- irreversible-operation gating
+- evidence recording
+- command construction without execution
+- execution through fake host implementations
+- target adapter contract tests
+
+Real integration tests can exist for official validators and sandbox registries, but the core should not depend on live services to prove its behavior.
+
+## Success Criteria
+
+The rewrite is successful when:
+
+- a user can define release intent in a small config
+- the package produces a reviewable release plan with no side effects
+- target differences are explicit in the plan
+- validation emits structured evidence
+- publish operations are blocked by default
+- irreversible operations require deliberate approval
+- core behavior is covered with deterministic tests
+- a CLI can be rebuilt as a thin adapter over the library
+- adding a new target does not require rewriting the core planner
+
+## Biases
+
+Prefer:
+
+- explicit data over implicit conventions
+- small target adapters over a large universal abstraction
+- official ecosystem validators over homegrown approximations
+- deterministic planning over clever runtime discovery
+- evidence artifacts over terminal-only output
+- hard failures for unsafe ambiguity
+- dry-run as the default mode
+
+Avoid:
+
+- hook-runner architecture as the core design
+- hidden publish side effects during validation
+- target adapters that silently shell out without modeling risk
+- global process state in the planning layer
+- special cases that only work for one repository shape
+- abstractions that erase important ecosystem differences
+
+## Rewrite Direction
+
+Start from the data model.
+
+Define the smallest set of types needed to represent release identity, artifacts, targets, operations, validation results, execution gates, and evidence. Then implement one or two target adapters end to end to prove that the abstractions carry real differences without becoming generic mush.
+
+The first working version should be narrow but honest:
+
+1. Load config.
+2. Normalize into a release model.
+3. Generate a serializable plan.
+4. Validate with structured evidence.
+5. Print executable operations.
+6. Execute only when explicitly approved.
+
+Everything else should be added only after it has a clear place in that flow.

package/dist/cli/command.d.ts

@@ -0,0 +1,4 @@
+import * as Command from "effect/unstable/cli/Command";
+export type * from "../types/effect-internal.js";
+export declare const cli: Command.Command<"release", {}, {}, import("../domain/operation.js").ExecutionApprovalError | import("../config/errors.js").ConfigParseError | import("../config/errors.js").ConfigValidationError | import("../host/host.js").HostError | import("../planner/errors.js").ReleaseNormalizationError | import("../planner/errors.js").PlanConstructionError | import("../planner/errors.js").EvidenceWriteError | import("../planner/errors.js").OperationFailedError | import("../targets/registry.js").MissingTargetAdapterError, never>;
+//# sourceMappingURL=command.d.ts.map

package/dist/cli/command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"command.d.ts","sourceRoot":"","sources":["../../src/cli/command.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,OAAO,MAAM,6BAA6B,CAAA;AAatD,mBAAmB,6BAA6B,CAAA;AA+IhD,eAAO,MAAM,GAAG,0gBAEf,CAAA"}

package/dist/cli/command.js

@@ -0,0 +1,90 @@
+import * as Console from "effect/Console";
+import * as Effect from "effect/Effect";
+import * as Command from "effect/unstable/cli/Command";
+import * as Flag from "effect/unstable/cli/Flag";
+import { parseReleaseIntent } from "../config/load.js";
+import { DEFAULT_CONFIG_PATH } from "../config/schema.js";
+import { ExecutionApproval } from "../domain/operation.js";
+import { ReleaseHost } from "../host/host.js";
+import { createReleasePlan } from "../planner/create-release-plan.js";
+import { executePlan, renderPlan, validatePlan, verifyPlan } from "../planner/executor.js";
+import { renderEvidenceJson, writeEvidenceBundle } from "../planner/evidence-recorder.js";
+import { renderPlanJson, renderPlanText } from "../planner/render-plan.js";
+const configFlag = Flag.string("config").pipe(Flag.withDefault(DEFAULT_CONFIG_PATH));
+const outputFlag = Flag.string("out").pipe(Flag.withDefault(""));
+const formatFlag = Flag.choice("format", ["json", "text"]).pipe(Flag.withDefault("json"));
+const executeFlag = Flag.boolean("execute").pipe(Flag.withDefault(false));
+const approveIrreversibleFlag = Flag.boolean("approve-irreversible").pipe(Flag.withDefault(false));
+const loadPlanFromConfig = Effect.fn("loadPlanFromConfig")(function* (configPath) {
+    const host = yield* ReleaseHost;
+    const contents = yield* host.readFileString(configPath);
+    const intent = yield* parseReleaseIntent(contents, configPath);
+    return yield* createReleasePlan(intent, ".", configPath);
+});
+const writeOrPrint = Effect.fn("writeOrPrint")(function* (out, contents) {
+    if (out.length === 0) {
+        return yield* Console.log(contents.trimEnd());
+    }
+    const host = yield* ReleaseHost;
+    return yield* host.writeFileString(out, contents);
+});
+const planCommand = Command.make("plan", {
+    config: configFlag,
+    out: outputFlag,
+    format: formatFlag
+}, Effect.fn("cli.plan")(function* ({ config, out, format }) {
+    const plan = yield* loadPlanFromConfig(config);
+    const contents = format === "json" ? renderPlanJson(plan) : renderPlanText(plan);
+    yield* writeOrPrint(out, contents);
+}));
+const printCommand = Command.make("print", {
+    config: configFlag
+}, Effect.fn("cli.print")(function* ({ config }) {
+    const plan = yield* loadPlanFromConfig(config);
+    yield* Console.log(renderPlanText(plan).trimEnd());
+}));
+const evidencePath = (plan, name) => `${plan.evidenceDirectory}/${name}.json`;
+const writeAndPrintEvidence = Effect.fn("writeAndPrintEvidence")(function* (plan, name, evidence) {
+    yield* writeEvidenceBundle(evidencePath(plan, name), evidence);
+    yield* Console.log(renderEvidenceJson(evidence).trimEnd());
+});
+const writeFailedEvidence = Effect.fn("writeFailedEvidence")(function* (plan, name, error) {
+    if (error.evidence !== undefined) {
+        yield* writeAndPrintEvidence(plan, name, error.evidence);
+    }
+});
+const validateCommand = Command.make("validate", {
+    config: configFlag
+}, Effect.fn("cli.validate")(function* ({ config }) {
+    const plan = yield* loadPlanFromConfig(config);
+    const evidence = yield* validatePlan(plan).pipe(Effect.catchTag("OperationFailedError", (error) => writeFailedEvidence(plan, "validation", error).pipe(Effect.flatMap(() => Effect.fail(error)))));
+    yield* writeAndPrintEvidence(plan, "validation", evidence);
+}));
+const renderCommand = Command.make("render", {
+    config: configFlag,
+    execute: executeFlag
+}, Effect.fn("cli.render")(function* ({ config, execute }) {
+    const plan = yield* loadPlanFromConfig(config);
+    const approval = ExecutionApproval.make({ execute, approveIrreversible: false });
+    const evidence = yield* renderPlan(plan, approval).pipe(Effect.catchTag("OperationFailedError", (error) => writeFailedEvidence(plan, "render", error).pipe(Effect.flatMap(() => Effect.fail(error)))));
+    yield* writeAndPrintEvidence(plan, "render", evidence);
+}));
+const executeCommand = Command.make("execute", {
+    config: configFlag,
+    execute: executeFlag,
+    approveIrreversible: approveIrreversibleFlag
+}, Effect.fn("cli.execute")(function* ({ config, execute, approveIrreversible }) {
+    const plan = yield* loadPlanFromConfig(config);
+    const approval = ExecutionApproval.make({ execute, approveIrreversible });
+    const evidence = yield* executePlan(plan, approval).pipe(Effect.catchTag("OperationFailedError", (error) => writeFailedEvidence(plan, "execution", error).pipe(Effect.flatMap(() => Effect.fail(error)))));
+    yield* writeAndPrintEvidence(plan, "execution", evidence);
+}));
+const verifyCommand = Command.make("verify", {
+    config: configFlag
+}, Effect.fn("cli.verify")(function* ({ config }) {
+    const plan = yield* loadPlanFromConfig(config);
+    const evidence = yield* verifyPlan(plan).pipe(Effect.catchTag("OperationFailedError", (error) => writeFailedEvidence(plan, "verification", error).pipe(Effect.flatMap(() => Effect.fail(error)))));
+    yield* writeAndPrintEvidence(plan, "verification", evidence);
+}));
+export const cli = Command.make("release").pipe(Command.withSubcommands([planCommand, renderCommand, validateCommand, printCommand, executeCommand, verifyCommand]));
+//# sourceMappingURL=command.js.map

package/dist/cli/command.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"command.js","sourceRoot":"","sources":["../../src/cli/command.ts"],"names":[],"mappings":"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"}

package/dist/cli/main.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env bun
+export {};
+//# sourceMappingURL=main.d.ts.map

package/dist/cli/main.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../src/cli/main.ts"],"names":[],"mappings":""}

package/dist/cli/main.js

@@ -0,0 +1,12 @@
+#!/usr/bin/env bun
+import * as BunRuntime from "@effect/platform-bun/BunRuntime";
+import * as BunServices from "@effect/platform-bun/BunServices";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Command from "effect/unstable/cli/Command";
+import { BunReleaseHostLayer } from "../host/bun.js";
+import { LiveTargetRegistryLayer } from "../targets/live.js";
+import { cli } from "./command.js";
+const MainLayer = Layer.mergeAll(BunReleaseHostLayer, LiveTargetRegistryLayer, BunServices.layer);
+Command.run(cli, { version: "0.0.0" }).pipe(Effect.provide(MainLayer), BunRuntime.runMain);
+//# sourceMappingURL=main.js.map

package/dist/cli/main.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"main.js","sourceRoot":"","sources":["../../src/cli/main.ts"],"names":[],"mappings":";AAEA,OAAO,KAAK,UAAU,MAAM,iCAAiC,CAAA;AAC7D,OAAO,KAAK,WAAW,MAAM,kCAAkC,CAAA;AAC/D,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AACrC,OAAO,KAAK,OAAO,MAAM,6BAA6B,CAAA;AACtD,OAAO,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAA;AACpD,OAAO,EAAE,uBAAuB,EAAE,MAAM,oBAAoB,CAAA;AAC5D,OAAO,EAAE,GAAG,EAAE,MAAM,cAAc,CAAA;AAElC,MAAM,SAAS,GAAG,KAAK,CAAC,QAAQ,CAC9B,mBAAmB,EACnB,uBAAuB,EACvB,WAAW,CAAC,KAAK,CAClB,CAAA;AAED,OAAO,CAAC,GAAG,CAAC,GAAG,EAAE,EAAE,OAAO,EAAE,OAAO,EAAE,CAAC,CAAC,IAAI,CACzC,MAAM,CAAC,OAAO,CAAC,SAAS,CAAC,EACzB,UAAU,CAAC,OAAO,CACnB,CAAA"}

package/dist/cli/programmatic.d.ts

@@ -0,0 +1,25 @@
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import { ReleasePlan } from "../domain/release.js";
+export type * from "../types/effect-internal.js";
+export declare const DEFAULT_RELEASE_CLI_VERSION = "0.0.0";
+export declare const ReleasePlanFormat: Schema.Literals<readonly ["json", "text"]>;
+export type ReleasePlanFormat = typeof ReleasePlanFormat.Type;
+declare const ReleaseCliOptions_base: Schema.Class<ReleaseCliOptions, Schema.Struct<{
+    readonly root: Schema.optionalKey<Schema.String>;
+    readonly version: Schema.optionalKey<Schema.String>;
+}>, {}>;
+export declare class ReleaseCliOptions extends ReleaseCliOptions_base {
+}
+declare const PlanReleaseConfigOptions_base: Schema.Class<PlanReleaseConfigOptions, Schema.Struct<{
+    readonly root: Schema.optionalKey<Schema.String>;
+    readonly configPath: Schema.optionalKey<Schema.String>;
+    readonly format: Schema.optionalKey<Schema.Literals<readonly ["json", "text"]>>;
+}>, {}>;
+export declare class PlanReleaseConfigOptions extends PlanReleaseConfigOptions_base {
+}
+export declare const planReleaseConfig: (options?: PlanReleaseConfigOptions | undefined) => Effect.Effect<ReleasePlan, import("../config/errors.js").ConfigParseError | import("../config/errors.js").ConfigValidationError | import("../host/host.js").HostError | import("../planner/errors.js").ReleaseNormalizationError | import("../planner/errors.js").PlanConstructionError | import("../targets/registry.js").MissingTargetAdapterError, never>;
+export declare const renderReleaseConfigPlan: (options?: PlanReleaseConfigOptions | undefined) => Effect.Effect<string, import("../config/errors.js").ConfigParseError | import("../config/errors.js").ConfigValidationError | import("../host/host.js").HostError | import("../planner/errors.js").ReleaseNormalizationError | import("../planner/errors.js").PlanConstructionError | import("../targets/registry.js").MissingTargetAdapterError, never>;
+export declare const runReleaseCli: (args: readonly string[], options?: ReleaseCliOptions | undefined) => Effect.Effect<void, import("effect/unstable/cli/CliError").CliError | import("../domain/operation.js").ExecutionApprovalError | import("../config/errors.js").ConfigParseError | import("../config/errors.js").ConfigValidationError | import("../host/host.js").HostError | import("../planner/errors.js").ReleaseNormalizationError | import("../planner/errors.js").PlanConstructionError | import("../planner/errors.js").EvidenceWriteError | import("../planner/errors.js").OperationFailedError | import("../targets/registry.js").MissingTargetAdapterError, never>;
+export type ProgrammaticReleasePlan = ReleasePlan;
+//# sourceMappingURL=programmatic.d.ts.map