@mannyc1/ts-release 0.0.6 → 0.0.7

package/SPEC.md

@@ -2,30 +2,32 @@
 
 ## Purpose
 
-The `release` package is a small TypeScript library for turning release intent into explicit, inspectable, and repeatable publishing operations.
+The `release` package is a small TypeScript library for turning installable artifacts into explicit, inspectable, and repeatable package-manager distribution plans.
 
-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.
+It should not be a fake universal package manager or a generic task runner. Its job is to model what is being distributed, which artifact variants exist, which package managers or install channels consume them, and which externally visible 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.
+The package should make distribution work boring: the same inputs should produce the same plan, the same staged artifacts should produce auditable inventory, and the same publish operation should be understandable before anything is executed.
 
 ## Core Idea
 
-A release is a data flow:
+A distribution is a data flow:
 
 ```text
 release intent
   -> normalized release model
+  -> artifact recipes and inventory
+  -> installable artifact variants
   -> target-specific operations
-  -> optional generated files
-  -> validation evidence
-  -> gated execution
+  -> generated package-manager files
+  -> validation and rendering evidence
+  -> approved execution
   -> post-publish verification
-  -> status and conservative resume
+  -> optional modeled reconciliation
 ```
 
 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.
+For example, npm, PyPI, GitHub Releases, Homebrew taps, Scoop buckets, OCI registries, app stores, or other targets may each need different manifests, commands, credentials, artifacts, and validators. The release package should describe those differences directly instead of hiding them behind one fake universal abstraction.
 
 ## Current Shape
 
@@ -34,11 +36,10 @@ The root package is the reusable library. It exposes explicit subpaths for domai
 Current first-party workflows cover:
 
 - config validation and plan rendering
+- explicit artifact recipe staging
 - data-first init/scaffolding previews with approved writes
 - static doctor/auth/CI diagnostics
 - render, validation, execution, verification, and workflow evidence
-- status reporting from existing evidence
-- conservative resume after interrupted work
 - narrow GitHub release reconciliation without republishing npm versions
 
 Reusable configs live in `templates/`, runnable fixtures live in `examples/`, and publish operations remain data until an execute approval and any irreversible approval are supplied.
@@ -47,12 +48,12 @@ Reusable configs live in `templates/`, runnable fixtures live in `examples/`, an
 
 ### Plan-first
 
-The primary output of the package is a release plan, not a side effect.
+The primary output of the package is a distribution 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, source metadata, and the strategy that resolved it
-- artifact inventory: files, checksums, sizes, formats, and intended consumers
+- release identity: name, version, commit, tag, notes, and source metadata
+- artifact inventory: files, checksums, sizes, formats, intended consumers, and installable variants
 - 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
@@ -77,7 +78,7 @@ 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.
 
-Evidence should also support status reporting and conservative resume after failed or interrupted releases.
+Evidence should also preserve enough context to debug failed or interrupted releases.
 
 Strict mode should fail on missing required validators. Non-strict mode may record skips, but skips must be visible in the evidence.
 
@@ -98,6 +99,7 @@ The core package should be a reusable library. A CLI can exist as an adapter, bu
 The library should expose APIs for:
 
 - loading and normalizing config
+- staging declared artifact recipes through provided adapters
 - constructing a release plan
 - scaffolding starter configs and CI workflows as proposed files
 - rendering config schemas and validation results
@@ -107,8 +109,6 @@ The library should expose APIs for:
 - preparing executable operations
 - running approved operations through an injected host interface
 - recording evidence
-- reporting release status from evidence
-- conservatively resuming safe unfinished work
 - reconciling narrowly modeled remote state without replaying immutable publishes
 
 The CLI and GitHub Action should mainly parse host inputs, call the library, format host-specific output, and persist evidence.
@@ -129,9 +129,9 @@ Builders, packagers, changelog generators, signing tools, registry CLIs, provena
 
 The package should not try to:
 
-- build every artifact itself
+- build every artifact itself or replace full build pipelines
 - replace ecosystem-native publishing tools
-- invent a universal package format
+- invent a universal package format or one manifest schema for every ecosystem
 - hide target-specific auth requirements
 - guarantee semantic versioning policy for the project using it
 - own changelog generation as a core requirement
@@ -149,9 +149,19 @@ 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.
 
-Identity may be static config data or may be derived from a package manifest. Decision strategies may then decide whether a release should be attempted from explicit remote-state config, the current Git tag, conventional commits since the latest matching tag, or first-party intent files. These strategies choose the intended identity and skipped/ready/complete/partial eligibility result; they do not publish.
+Identity may be static config data or may be derived from a package manifest. Release intent should declare artifact files, optional artifact recipes, target policy, and evidence location. Whether a project decides to bump a version from tags, commits, or human review belongs outside the generic distribution model unless it becomes a separate app-local or target-specific adapter.
 
-Intent files are a small first-party reviewed-intent format, not a promise of full Changesets compatibility. An empty/no-release intent can satisfy CI while producing a skipped release decision.
+### Artifact Recipe
+
+An optional, explicit staging contract for artifacts that `ts-release` can create before planning target distribution.
+
+Recipes are data until the caller runs a staging workflow. The first recipe family is Bun executable compilation, which produces executable artifacts with derived operating-system and architecture variants. Additional recipe families should land only when they provide durable distribution value without turning the core into a general build system.
+
+### Installable Artifact Variant
+
+Platform metadata attached to an artifact intent or inventory item.
+
+Variants should capture facts that package-manager targets need to choose or render the right artifact: operating system, architecture, optional Linux libc family, executable extension, binary name, install path, and source target triple. Target adapters should consume this data instead of guessing from filenames.
 
 ### Release Model
 
@@ -189,6 +199,7 @@ The package should make these workflows straightforward:
 
 - initialize a starter config and optional CI workflow from templates
 - validate config JSON and schema shape
+- stage declared artifact recipes
 - create a plan from config
 - inspect the plan without executing anything
 - render target-specific files
@@ -198,7 +209,6 @@ The package should make these workflows straightforward:
 - print publish operations
 - execute approved operations
 - verify published state after execution
-- inspect status and resume only safe unfinished work
 - reconcile a matching GitHub draft release without republishing immutable registries
 
 The API should favor explicit functions and typed data over hidden global state.
@@ -212,22 +222,14 @@ It should describe release facts and target policy, not arbitrary scripts. Escap
 Good config answers:
 
 - What is the release?
-- Which artifacts are part of it?
-- Which targets receive it?
+- Which artifacts and variants are part of it?
+- Which targets or install surfaces receive them?
 - 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?
 
-Release strategies should stay declarative:
-
-- static config is for manually audited release identity
-- package manifest identity is for package releases with one version source
-- Git tag decisions are for tag-triggered workflows
-- conventional commit decisions are for automated SemVer from commit messages
-- intent-file decisions are for release intent reviewed in PRs
-
-Artifact path templates may interpolate only named release data such as `{version}`, `{name}`, and `{normalizedName}`. They must be expanded before path safety and artifact inventory checks.
+Artifact path templates may interpolate only named release data such as `{version}`, `{name}`, and `{normalizedName}`. They must be expanded before path safety and artifact inventory checks. Artifact variants must be explicit data or derived by a known recipe adapter before target rendering.
 
 ## Testing Strategy
 
@@ -252,9 +254,11 @@ Real integration tests can exist for official validators and sandbox registries,
 
 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
+- a user can define an artifact-first distribution intent in a small config
+- the package can stage declared artifacts before target planning
+- the package produces a reviewable distribution plan with no side effects
 - target differences are explicit in the plan
+- installable artifact variants are available before package-manager rendering
 - validation emits structured evidence
 - publish operations are blocked by default
 - irreversible operations require deliberate approval
@@ -289,17 +293,18 @@ Avoid:
 
 Continue from the data model.
 
-Keep the smallest set of types needed to represent release identity, artifacts, targets, operations, validation results, execution gates, and evidence. Add target adapters end to end only when they prove the abstractions carry real differences without becoming generic mush.
+Keep the smallest set of types needed to represent release identity, artifact recipes, artifact variants, targets, operations, validation results, execution gates, and evidence. Add target adapters end to end only when they prove the abstractions carry real differences without becoming generic mush.
 
 The implementation should stay narrow but honest:
 
 1. Load config.
-2. Normalize into a release model.
-3. Generate a serializable plan.
-4. Render generated files only through explicit render operations.
-5. Validate with structured evidence.
-6. Print executable operations.
-7. Execute only when explicitly approved.
-8. Verify remote state and report status from evidence.
+2. Stage declared artifact recipes when requested.
+3. Normalize into a release model with artifact inventory and variants.
+4. Generate a serializable distribution plan.
+5. Render generated files only through explicit render operations.
+6. Validate with structured evidence.
+7. Print executable operations.
+8. Execute only when explicitly approved.
+9. Verify remote state and record evidence.
 
 Everything else should be added only after it has a clear place in that flow.

package/dist/artifacts/adapter.d.ts

@@ -0,0 +1,39 @@
+import * as Effect from "effect/Effect";
+import type * as Path from "effect/Path";
+import * as Schema from "effect/Schema";
+import { ArtifactRecipe } from "../domain/artifact.js";
+import { ReleaseIdentity } from "../domain/release.js";
+export type * from "../types/effect-internal.js";
+export interface ArtifactRecipeStageContext {
+    readonly root: string;
+    readonly identity: ReleaseIdentity;
+    readonly configPath?: string | undefined;
+}
+declare const StagedArtifact_base: Schema.Class<StagedArtifact, Schema.Struct<{
+    readonly id: Schema.NonEmptyString;
+    readonly path: Schema.String;
+}>, {}>;
+export declare class StagedArtifact extends StagedArtifact_base {
+}
+declare const StagedArtifactRecipeResult_base: Schema.Class<StagedArtifactRecipeResult, Schema.Struct<{
+    readonly recipeId: Schema.NonEmptyString;
+    readonly recipeTag: Schema.String;
+    readonly artifacts: Schema.$Array<typeof StagedArtifact>;
+}>, {}>;
+export declare class StagedArtifactRecipeResult extends StagedArtifactRecipeResult_base {
+}
+declare const ArtifactRecipeStageError_base: Schema.Class<ArtifactRecipeStageError, Schema.TaggedStruct<"ArtifactRecipeStageError", {
+    readonly recipeId: Schema.NonEmptyString;
+    readonly recipeTag: Schema.String;
+    readonly artifactId: Schema.optionalKey<Schema.NonEmptyString>;
+    readonly path: Schema.optionalKey<Schema.String>;
+    readonly reason: Schema.String;
+    readonly cause: Schema.optionalKey<Schema.Defect>;
+}>, import("effect/Cause").YieldableError>;
+export declare class ArtifactRecipeStageError extends ArtifactRecipeStageError_base {
+}
+export interface ArtifactRecipeAdapter<Recipe extends ArtifactRecipe> {
+    readonly recipeTag: Recipe["_tag"];
+    readonly stage: (recipe: Recipe, context: ArtifactRecipeStageContext) => Effect.Effect<StagedArtifactRecipeResult, ArtifactRecipeStageError, Path.Path>;
+}
+//# sourceMappingURL=adapter.d.ts.map

package/dist/artifacts/adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../../src/artifacts/adapter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,KAAK,IAAI,MAAM,aAAa,CAAA;AACxC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,EAEL,cAAc,EAEf,MAAM,uBAAuB,CAAA;AAC9B,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAA;AAEtD,mBAAmB,6BAA6B,CAAA;AAEhD,MAAM,WAAW,0BAA0B;IACzC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,QAAQ,EAAE,eAAe,CAAA;IAClC,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;CACzC;;;;;AAED,qBAAa,cAAe,SAAQ,mBAGlC;CAAG;;;;;;AAEL,qBAAa,0BAA2B,SAAQ,+BAM9C;CAAG;;;;;;;;;AAEL,qBAAa,wBAAyB,SAAQ,6BAU7C;CAAG;AAEJ,MAAM,WAAW,qBAAqB,CAAC,MAAM,SAAS,cAAc;IAClE,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC,MAAM,CAAC,CAAA;IAClC,QAAQ,CAAC,KAAK,EAAE,CACd,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,0BAA0B,KAChC,MAAM,CAAC,MAAM,CAAC,0BAA0B,EAAE,wBAAwB,EAAE,IAAI,CAAC,IAAI,CAAC,CAAA;CACpF"}

package/dist/artifacts/adapter.js

@@ -0,0 +1,23 @@
+import * as Schema from "effect/Schema";
+import { ArtifactId, ArtifactRecipeId } from "../domain/artifact.js";
+export class StagedArtifact extends Schema.Class("StagedArtifact")({
+    id: ArtifactId,
+    path: Schema.String
+}) {
+}
+export class StagedArtifactRecipeResult extends Schema.Class("StagedArtifactRecipeResult")({
+    recipeId: ArtifactRecipeId,
+    recipeTag: Schema.String,
+    artifacts: Schema.Array(StagedArtifact)
+}) {
+}
+export class ArtifactRecipeStageError extends Schema.TaggedErrorClass()("ArtifactRecipeStageError", {
+    recipeId: ArtifactRecipeId,
+    recipeTag: Schema.String,
+    artifactId: Schema.optionalKey(ArtifactId),
+    path: Schema.optionalKey(Schema.String),
+    reason: Schema.String,
+    cause: Schema.optionalKey(Schema.Defect())
+}) {
+}
+//# sourceMappingURL=adapter.js.map

package/dist/artifacts/adapter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.js","sourceRoot":"","sources":["../../src/artifacts/adapter.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,EACL,UAAU,EAEV,gBAAgB,EACjB,MAAM,uBAAuB,CAAA;AAW9B,MAAM,OAAO,cAAe,SAAQ,MAAM,CAAC,KAAK,CAAiB,gBAAgB,CAAC,CAAC;IACjF,EAAE,EAAE,UAAU;IACd,IAAI,EAAE,MAAM,CAAC,MAAM;CACpB,CAAC;CAAG;AAEL,MAAM,OAAO,0BAA2B,SAAQ,MAAM,CAAC,KAAK,CAC1D,4BAA4B,CAC7B,CAAC;IACA,QAAQ,EAAE,gBAAgB;IAC1B,SAAS,EAAE,MAAM,CAAC,MAAM;IACxB,SAAS,EAAE,MAAM,CAAC,KAAK,CAAC,cAAc,CAAC;CACxC,CAAC;CAAG;AAEL,MAAM,OAAO,wBAAyB,SAAQ,MAAM,CAAC,gBAAgB,EAA4B,CAC/F,0BAA0B,EAC1B;IACE,QAAQ,EAAE,gBAAgB;IAC1B,SAAS,EAAE,MAAM,CAAC,MAAM;IACxB,UAAU,EAAE,MAAM,CAAC,WAAW,CAAC,UAAU,CAAC;IAC1C,IAAI,EAAE,MAAM,CAAC,WAAW,CAAC,MAAM,CAAC,MAAM,CAAC;IACvC,MAAM,EAAE,MAAM,CAAC,MAAM;IACrB,KAAK,EAAE,MAAM,CAAC,WAAW,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC;CAC3C,CACF;CAAG"}

package/dist/artifacts/registry.d.ts

@@ -0,0 +1,21 @@
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import type * as Path from "effect/Path";
+import * as Schema from "effect/Schema";
+import { ArtifactRecipe } from "../domain/artifact.js";
+import { ArtifactRecipeStageContext, ArtifactRecipeStageError, StagedArtifactRecipeResult } from "./adapter.js";
+export type * from "../types/effect-internal.js";
+declare const MissingArtifactRecipeAdapterError_base: Schema.Class<MissingArtifactRecipeAdapterError, Schema.TaggedStruct<"MissingArtifactRecipeAdapterError", {
+    readonly recipeTag: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class MissingArtifactRecipeAdapterError extends MissingArtifactRecipeAdapterError_base {
+}
+export interface ArtifactRecipeRegistryShape {
+    readonly stageArtifactRecipe: (recipe: ArtifactRecipe, context: ArtifactRecipeStageContext) => Effect.Effect<StagedArtifactRecipeResult, MissingArtifactRecipeAdapterError | ArtifactRecipeStageError, Path.Path>;
+}
+declare const ArtifactRecipeRegistry_base: Context.ServiceClass<ArtifactRecipeRegistry, "ArtifactRecipeRegistry", ArtifactRecipeRegistryShape>;
+export declare class ArtifactRecipeRegistry extends ArtifactRecipeRegistry_base {
+}
+export declare const stageArtifactRecipe: (recipe: import("../domain/artifact.js").BunExecutableArtifactRecipe | import("../domain/artifact.js").PyPiWheelArtifactRecipe, context: ArtifactRecipeStageContext) => Effect.Effect<StagedArtifactRecipeResult, ArtifactRecipeStageError | MissingArtifactRecipeAdapterError, Path.Path | ArtifactRecipeRegistry>;
+export declare const stageAllArtifactRecipes: (recipes: readonly (import("../domain/artifact.js").BunExecutableArtifactRecipe | import("../domain/artifact.js").PyPiWheelArtifactRecipe)[], context: ArtifactRecipeStageContext) => Effect.Effect<StagedArtifactRecipeResult[], ArtifactRecipeStageError | MissingArtifactRecipeAdapterError, Path.Path | ArtifactRecipeRegistry>;
+//# sourceMappingURL=registry.d.ts.map

package/dist/artifacts/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/artifacts/registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,gBAAgB,CAAA;AACzC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,KAAK,IAAI,MAAM,aAAa,CAAA;AACxC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAA;AACtD,OAAO,EACL,0BAA0B,EAC1B,wBAAwB,EACxB,0BAA0B,EAC3B,MAAM,cAAc,CAAA;AAErB,mBAAmB,6BAA6B,CAAA;;;;AAEhD,qBAAa,iCAAkC,SAAQ,sCAKtD;CAAG;AAEJ,MAAM,WAAW,2BAA2B;IAC1C,QAAQ,CAAC,mBAAmB,EAAE,CAC5B,MAAM,EAAE,cAAc,EACtB,OAAO,EAAE,0BAA0B,KAChC,MAAM,CAAC,MAAM,CAAC,0BAA0B,EAAE,iCAAiC,GAAG,wBAAwB,EAAE,IAAI,CAAC,IAAI,CAAC,CAAA;CACxH;;AAED,qBAAa,sBAAuB,SAAQ,2BAGf;CAAG;AAEhC,eAAO,MAAM,mBAAmB,qTAM9B,CAAA;AAEF,eAAO,MAAM,uBAAuB,qUASlC,CAAA"}

package/dist/artifacts/registry.js

@@ -0,0 +1,21 @@
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+export class MissingArtifactRecipeAdapterError extends Schema.TaggedErrorClass()("MissingArtifactRecipeAdapterError", {
+    recipeTag: Schema.String
+}) {
+}
+export class ArtifactRecipeRegistry extends Context.Service()("ArtifactRecipeRegistry") {
+}
+export const stageArtifactRecipe = Effect.fn("stageArtifactRecipe")(function* (recipe, context) {
+    const registry = yield* ArtifactRecipeRegistry;
+    return yield* registry.stageArtifactRecipe(recipe, context);
+});
+export const stageAllArtifactRecipes = Effect.fn("stageAllArtifactRecipes")(function* (recipes, context) {
+    const results = [];
+    for (const recipe of recipes) {
+        results.push(yield* stageArtifactRecipe(recipe, context));
+    }
+    return results;
+});
+//# sourceMappingURL=registry.js.map

package/dist/artifacts/registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.js","sourceRoot":"","sources":["../../src/artifacts/registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,gBAAgB,CAAA;AACzC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAUvC,MAAM,OAAO,iCAAkC,SAAQ,MAAM,CAAC,gBAAgB,EAAqC,CACjH,mCAAmC,EACnC;IACE,SAAS,EAAE,MAAM,CAAC,MAAM;CACzB,CACF;CAAG;AASJ,MAAM,OAAO,sBAAuB,SAAQ,OAAO,CAAC,OAAO,EAGxD,CAAC,wBAAwB,CAAC;CAAG;AAEhC,MAAM,CAAC,MAAM,mBAAmB,GAAG,MAAM,CAAC,EAAE,CAAC,qBAAqB,CAAC,CAAC,QAAQ,CAAC,EAC3E,MAAsB,EACtB,OAAmC;IAEnC,MAAM,QAAQ,GAAG,KAAK,CAAC,CAAC,sBAAsB,CAAA;IAC9C,OAAO,KAAK,CAAC,CAAC,QAAQ,CAAC,mBAAmB,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;AAC7D,CAAC,CAAC,CAAA;AAEF,MAAM,CAAC,MAAM,uBAAuB,GAAG,MAAM,CAAC,EAAE,CAAC,yBAAyB,CAAC,CAAC,QAAQ,CAAC,EACnF,OAAsC,EACtC,OAAmC;IAEnC,MAAM,OAAO,GAAsC,EAAE,CAAA;IACrD,KAAK,MAAM,MAAM,IAAI,OAAO,EAAE,CAAC;QAC7B,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,mBAAmB,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;IAC3D,CAAC;IACD,OAAO,OAAO,CAAA;AAChB,CAAC,CAAC,CAAA"}

package/dist/config/schema.js

@@ -11,7 +11,7 @@ export const releaseConfigJsonSchemaDocument = () => {
         $schema: "https://json-schema.org/draft/2020-12/schema",
         $id: RELEASE_CONFIG_SCHEMA_ID,
         title: "ts-release configuration",
-        description: "Configuration for a plan-first ts-release workflow.",
+        description: "Configuration for an artifact-first ts-release distribution workflow.",
         $defs: document.definitions
     };
 };

package/dist/config/schema.js.map

@@ -1 +1 @@
-{"version":3,"file":"schema.js","sourceRoot":"","sources":["../../src/config/schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAA;AAIpD,MAAM,CAAC,MAAM,mBAAmB,GAAG,qBAAqB,CAAA;AACxD,MAAM,CAAC,MAAM,wBAAwB,GAAG,wEAAwE,CAAA;AAEhH,MAAM,CAAC,MAAM,aAAa,GAAG,aAAa,CAAA;AAG1C,MAAM,CAAC,MAAM,mBAAmB,GAAG,MAAM,CAAC,mBAAmB,CAAC,aAAa,CAAC,CAAA;AAE5E,MAAM,CAAC,MAAM,+BAA+B,GAAG,GAA0B,EAAE;IACzE,MAAM,QAAQ,GAAG,MAAM,CAAC,oBAAoB,CAAC,aAAa,CAAC,CAAA;IAC3D,OAAO;QACL,GAAG,QAAQ,CAAC,MAAM;QAClB,OAAO,EAAE,8CAA8C;QACvD,GAAG,EAAE,wBAAwB;QAC7B,KAAK,EAAE,0BAA0B;QACjC,WAAW,EAAE,qDAAqD;QAClE,KAAK,EAAE,QAAQ,CAAC,WAAW;KAC5B,CAAA;AACH,CAAC,CAAA;AAED,MAAM,CAAC,MAAM,6BAA6B,GAAG,GAAW,EAAE,CACxD,GAAG,IAAI,CAAC,SAAS,CAAC,+BAA+B,EAAE,EAAE,IAAI,EAAE,CAAC,CAAC,IAAI,CAAA"}
+{"version":3,"file":"schema.js","sourceRoot":"","sources":["../../src/config/schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAA;AAIpD,MAAM,CAAC,MAAM,mBAAmB,GAAG,qBAAqB,CAAA;AACxD,MAAM,CAAC,MAAM,wBAAwB,GAAG,wEAAwE,CAAA;AAEhH,MAAM,CAAC,MAAM,aAAa,GAAG,aAAa,CAAA;AAG1C,MAAM,CAAC,MAAM,mBAAmB,GAAG,MAAM,CAAC,mBAAmB,CAAC,aAAa,CAAC,CAAA;AAE5E,MAAM,CAAC,MAAM,+BAA+B,GAAG,GAA0B,EAAE;IACzE,MAAM,QAAQ,GAAG,MAAM,CAAC,oBAAoB,CAAC,aAAa,CAAC,CAAA;IAC3D,OAAO;QACL,GAAG,QAAQ,CAAC,MAAM;QAClB,OAAO,EAAE,8CAA8C;QACvD,GAAG,EAAE,wBAAwB;QAC7B,KAAK,EAAE,0BAA0B;QACjC,WAAW,EAAE,uEAAuE;QACpF,KAAK,EAAE,QAAQ,CAAC,WAAW;KAC5B,CAAA;AACH,CAAC,CAAA;AAED,MAAM,CAAC,MAAM,6BAA6B,GAAG,GAAW,EAAE,CACxD,GAAG,IAAI,CAAC,SAAS,CAAC,+BAA+B,EAAE,EAAE,IAAI,EAAE,CAAC,CAAC,IAAI,CAAA"}

package/dist/domain/artifact.d.ts

@@ -2,35 +2,117 @@ import * as Schema from "effect/Schema";
 export type * from "../types/effect-internal.js";
 export declare const ArtifactId: Schema.NonEmptyString;
 export type ArtifactId = typeof ArtifactId.Type;
-export declare const ArtifactFormat: Schema.Literals<readonly ["tarball", "zip", "file", "directory", "oci-image"]>;
+export declare const ArtifactFormat: Schema.Literals<readonly ["tarball", "zip", "file", "directory", "oci-image", "executable"]>;
 export type ArtifactFormat = typeof ArtifactFormat.Type;
 export declare const ChecksumAlgorithm: Schema.Literals<readonly ["sha256", "sha512"]>;
 export type ChecksumAlgorithm = typeof ChecksumAlgorithm.Type;
+export declare const ArtifactRecipeId: Schema.NonEmptyString;
+export type ArtifactRecipeId = typeof ArtifactRecipeId.Type;
+export declare const ArtifactOperatingSystem: Schema.Literals<readonly ["linux", "darwin", "windows"]>;
+export type ArtifactOperatingSystem = typeof ArtifactOperatingSystem.Type;
+export declare const ArtifactArchitecture: Schema.Literals<readonly ["x64", "arm64"]>;
+export type ArtifactArchitecture = typeof ArtifactArchitecture.Type;
+export declare const ArtifactLibc: Schema.Literals<readonly ["glibc", "musl"]>;
+export type ArtifactLibc = typeof ArtifactLibc.Type;
+export declare const BunExecutableCompileTarget: Schema.Literals<readonly ["bun-linux-x64", "bun-linux-x64-baseline", "bun-linux-x64-modern", "bun-linux-arm64", "bun-windows-x64", "bun-windows-x64-baseline", "bun-windows-x64-modern", "bun-windows-arm64", "bun-darwin-x64", "bun-darwin-x64-baseline", "bun-darwin-x64-modern", "bun-darwin-arm64", "bun-linux-x64-musl", "bun-linux-x64-baseline-musl", "bun-linux-x64-modern-musl", "bun-linux-arm64-musl"]>;
+export type BunExecutableCompileTarget = typeof BunExecutableCompileTarget.Type;
 declare const Checksum_base: Schema.Class<Checksum, Schema.Struct<{
     readonly algorithm: Schema.Literals<readonly ["sha256", "sha512"]>;
     readonly value: Schema.String;
 }>, {}>;
 export declare class Checksum extends Checksum_base {
 }
+declare const InstallableArtifactVariant_base: Schema.Class<InstallableArtifactVariant, Schema.Struct<{
+    readonly os: Schema.Literals<readonly ["linux", "darwin", "windows"]>;
+    readonly arch: Schema.Literals<readonly ["x64", "arm64"]>;
+    readonly libc: Schema.optionalKey<Schema.Literals<readonly ["glibc", "musl"]>>;
+    readonly binaryName: Schema.optionalKey<Schema.NonEmptyString>;
+    readonly executableExtension: Schema.optionalKey<Schema.NonEmptyString>;
+    readonly installPath: Schema.optionalKey<Schema.NonEmptyString>;
+    readonly targetTriple: Schema.optionalKey<Schema.NonEmptyString>;
+}>, {}>;
+export declare class InstallableArtifactVariant extends InstallableArtifactVariant_base {
+}
+declare const InstallableArtifactVariantOverride_base: Schema.Class<InstallableArtifactVariantOverride, Schema.Struct<{
+    readonly os: Schema.optionalKey<Schema.Literals<readonly ["linux", "darwin", "windows"]>>;
+    readonly arch: Schema.optionalKey<Schema.Literals<readonly ["x64", "arm64"]>>;
+    readonly libc: Schema.optionalKey<Schema.Literals<readonly ["glibc", "musl"]>>;
+    readonly binaryName: Schema.optionalKey<Schema.NonEmptyString>;
+    readonly executableExtension: Schema.optionalKey<Schema.NonEmptyString>;
+    readonly installPath: Schema.optionalKey<Schema.NonEmptyString>;
+    readonly targetTriple: Schema.optionalKey<Schema.NonEmptyString>;
+}>, {}>;
+export declare class InstallableArtifactVariantOverride extends InstallableArtifactVariantOverride_base {
+}
 declare const ArtifactIntent_base: Schema.Class<ArtifactIntent, Schema.Struct<{
     readonly id: Schema.NonEmptyString;
     readonly path: Schema.String;
-    readonly format: Schema.Literals<readonly ["tarball", "zip", "file", "directory", "oci-image"]>;
+    readonly downloadUrl: Schema.optionalKey<Schema.String>;
+    readonly format: Schema.Literals<readonly ["tarball", "zip", "file", "directory", "oci-image", "executable"]>;
     readonly consumers: Schema.$Array<Schema.String>;
     readonly checksum: Schema.optionalKey<typeof Checksum>;
+    readonly variant: Schema.optionalKey<typeof InstallableArtifactVariant>;
 }>, {}>;
 export declare class ArtifactIntent extends ArtifactIntent_base {
 }
+declare const BunExecutableArtifactOutput_base: Schema.Class<BunExecutableArtifactOutput, Schema.Struct<{
+    readonly id: Schema.NonEmptyString;
+    readonly target: Schema.Literals<readonly ["bun-linux-x64", "bun-linux-x64-baseline", "bun-linux-x64-modern", "bun-linux-arm64", "bun-windows-x64", "bun-windows-x64-baseline", "bun-windows-x64-modern", "bun-windows-arm64", "bun-darwin-x64", "bun-darwin-x64-baseline", "bun-darwin-x64-modern", "bun-darwin-arm64", "bun-linux-x64-musl", "bun-linux-x64-baseline-musl", "bun-linux-x64-modern-musl", "bun-linux-arm64-musl"]>;
+    readonly path: Schema.String;
+    readonly downloadUrl: Schema.optionalKey<Schema.String>;
+    readonly consumers: Schema.$Array<Schema.String>;
+    readonly variant: Schema.optionalKey<typeof InstallableArtifactVariantOverride>;
+}>, {}>;
+export declare class BunExecutableArtifactOutput extends BunExecutableArtifactOutput_base {
+}
+declare const BunExecutableArtifactRecipe_base: Schema.Class<BunExecutableArtifactRecipe, Schema.TaggedStruct<"BunExecutableArtifactRecipe", {
+    readonly id: Schema.NonEmptyString;
+    readonly entrypoint: Schema.String;
+    readonly outputs: Schema.$Array<typeof BunExecutableArtifactOutput>;
+    readonly minify: Schema.optionalKey<Schema.Boolean>;
+}>, {}>;
+export declare class BunExecutableArtifactRecipe extends BunExecutableArtifactRecipe_base {
+}
+declare const PyPiWheelBinaryArtifact_base: Schema.Class<PyPiWheelBinaryArtifact, Schema.Struct<{
+    readonly os: Schema.Literals<readonly ["linux", "darwin", "windows"]>;
+    readonly arch: Schema.Literals<readonly ["x64", "arm64"]>;
+    readonly sourcePath: Schema.String;
+    readonly wheelPath: Schema.String;
+}>, {}>;
+export declare class PyPiWheelBinaryArtifact extends PyPiWheelBinaryArtifact_base {
+}
+declare const PyPiWheelArtifactRecipe_base: Schema.Class<PyPiWheelArtifactRecipe, Schema.TaggedStruct<"PyPiWheelArtifactRecipe", {
+    readonly id: Schema.NonEmptyString;
+    readonly path: Schema.String;
+    readonly wheelTag: Schema.String;
+    readonly packageName: Schema.String;
+    readonly moduleName: Schema.String;
+    readonly consoleScript: Schema.String;
+    readonly summary: Schema.String;
+    readonly homepage: Schema.String;
+    readonly license: Schema.String;
+    readonly requiresPython: Schema.String;
+    readonly binaries: Schema.$Array<typeof PyPiWheelBinaryArtifact>;
+    readonly consumers: Schema.$Array<Schema.String>;
+}>, {}>;
+export declare class PyPiWheelArtifactRecipe extends PyPiWheelArtifactRecipe_base {
+}
+export declare const ArtifactRecipe: Schema.Union<readonly [typeof BunExecutableArtifactRecipe, typeof PyPiWheelArtifactRecipe]>;
+export type ArtifactRecipe = typeof ArtifactRecipe.Type;
 declare const ArtifactInventoryItem_base: Schema.Class<ArtifactInventoryItem, Schema.Struct<{
     readonly id: Schema.NonEmptyString;
     readonly path: Schema.String;
-    readonly format: Schema.Literals<readonly ["tarball", "zip", "file", "directory", "oci-image"]>;
+    readonly downloadUrl: Schema.optionalKey<Schema.String>;
+    readonly format: Schema.Literals<readonly ["tarball", "zip", "file", "directory", "oci-image", "executable"]>;
     readonly consumers: Schema.$Array<Schema.String>;
     readonly sizeBytes: Schema.Number;
     readonly checksum: Schema.optionalKey<typeof Checksum>;
+    readonly variant: Schema.optionalKey<typeof InstallableArtifactVariant>;
 }>, {}>;
 export declare class ArtifactInventoryItem extends ArtifactInventoryItem_base {
 }
+export declare const bunExecutableCompileTargetVariant: (target: BunExecutableCompileTarget) => InstallableArtifactVariant;
+export declare const bunExecutableOutputVariant: (target: BunExecutableCompileTarget, override: InstallableArtifactVariantOverride | undefined) => InstallableArtifactVariant;
 export declare const artifactIntentOrder: (left: ArtifactIntent, right: ArtifactIntent) => number;
 export declare const artifactInventoryOrder: (left: ArtifactInventoryItem, right: ArtifactInventoryItem) => number;
 //# sourceMappingURL=artifact.d.ts.map

package/dist/domain/artifact.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"artifact.d.ts","sourceRoot":"","sources":["../../src/domain/artifact.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC,mBAAmB,6BAA6B,CAAA;AAEhD,eAAO,MAAM,UAAU,uBAAwB,CAAA;AAC/C,MAAM,MAAM,UAAU,GAAG,OAAO,UAAU,CAAC,IAAI,CAAA;AAE/C,eAAO,MAAM,cAAc,gFAAwE,CAAA;AACnG,MAAM,MAAM,cAAc,GAAG,OAAO,cAAc,CAAC,IAAI,CAAA;AAEvD,eAAO,MAAM,iBAAiB,gDAAwC,CAAA;AACtE,MAAM,MAAM,iBAAiB,GAAG,OAAO,iBAAiB,CAAC,IAAI,CAAA;;;;;AAE7D,qBAAa,QAAS,SAAQ,aAG5B;CAAG;;;;;;;;AAEL,qBAAa,cAAe,SAAQ,mBAMlC;CAAG;;;;;;;;;AAEL,qBAAa,qBAAsB,SAAQ,0BAOzC;CAAG;AAEL,eAAO,MAAM,mBAAmB,GAAI,MAAM,cAAc,EAAE,OAAO,cAAc,KAAG,MACjD,CAAA;AAEjC,eAAO,MAAM,sBAAsB,GACjC,MAAM,qBAAqB,EAC3B,OAAO,qBAAqB,KAC3B,MAAyC,CAAA"}
+{"version":3,"file":"artifact.d.ts","sourceRoot":"","sources":["../../src/domain/artifact.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC,mBAAmB,6BAA6B,CAAA;AAEhD,eAAO,MAAM,UAAU,uBAAwB,CAAA;AAC/C,MAAM,MAAM,UAAU,GAAG,OAAO,UAAU,CAAC,IAAI,CAAA;AAE/C,eAAO,MAAM,cAAc,8FAAsF,CAAA;AACjH,MAAM,MAAM,cAAc,GAAG,OAAO,cAAc,CAAC,IAAI,CAAA;AAEvD,eAAO,MAAM,iBAAiB,gDAAwC,CAAA;AACtE,MAAM,MAAM,iBAAiB,GAAG,OAAO,iBAAiB,CAAC,IAAI,CAAA;AAE7D,eAAO,MAAM,gBAAgB,uBAAwB,CAAA;AACrD,MAAM,MAAM,gBAAgB,GAAG,OAAO,gBAAgB,CAAC,IAAI,CAAA;AAE3D,eAAO,MAAM,uBAAuB,0DAAkD,CAAA;AACtF,MAAM,MAAM,uBAAuB,GAAG,OAAO,uBAAuB,CAAC,IAAI,CAAA;AAEzE,eAAO,MAAM,oBAAoB,4CAAoC,CAAA;AACrE,MAAM,MAAM,oBAAoB,GAAG,OAAO,oBAAoB,CAAC,IAAI,CAAA;AAEnE,eAAO,MAAM,YAAY,6CAAqC,CAAA;AAC9D,MAAM,MAAM,YAAY,GAAG,OAAO,YAAY,CAAC,IAAI,CAAA;AAEnD,eAAO,MAAM,0BAA0B,oZAiBrC,CAAA;AACF,MAAM,MAAM,0BAA0B,GAAG,OAAO,0BAA0B,CAAC,IAAI,CAAA;;;;;AAE/E,qBAAa,QAAS,SAAQ,aAG5B;CAAG;;;;;;;;;;AAEL,qBAAa,0BAA2B,SAAQ,+BAU9C;CAAG;;;;;;;;;;AAEL,qBAAa,kCAAmC,SAAQ,uCAUtD;CAAG;;;;;;;;;;AAEL,qBAAa,cAAe,SAAQ,mBAQlC;CAAG;;;;;;;;;AAEL,qBAAa,2BAA4B,SAAQ,gCAS/C;CAAG;;;;;;;AAEL,qBAAa,2BAA4B,SAAQ,gCAQhD;CAAG;;;;;;;AAEJ,qBAAa,uBAAwB,SAAQ,4BAK3C;CAAG;;;;;;;;;;;;;;;AAEL,qBAAa,uBAAwB,SAAQ,4BAgB5C;CAAG;AAEJ,eAAO,MAAM,cAAc,6FAAuE,CAAA;AAClG,MAAM,MAAM,cAAc,GAAG,OAAO,cAAc,CAAC,IAAI,CAAA;;;;;;;;;;;AAEvD,qBAAa,qBAAsB,SAAQ,0BASzC;CAAG;AAEL,eAAO,MAAM,iCAAiC,GAC5C,QAAQ,0BAA0B,KACjC,0BAiEF,CAAA;AAED,eAAO,MAAM,0BAA0B,GACrC,QAAQ,0BAA0B,EAClC,UAAU,kCAAkC,GAAG,SAAS,KACvD,0BAgBF,CAAA;AAED,eAAO,MAAM,mBAAmB,GAAI,MAAM,cAAc,EAAE,OAAO,cAAc,KAAG,MACjD,CAAA;AAEjC,eAAO,MAAM,sBAAsB,GACjC,MAAM,qBAAqB,EAC3B,OAAO,qBAAqB,KAC3B,MAAyC,CAAA"}