@h-rig/contracts 0.0.6-alpha.17 → 0.0.6-alpha.170

package/dist/src/session-asset-materializer.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Pure session-asset-materializer contract.
+ *
+ * Neutral home for the "materialize plugin-contributed session assets into the
+ * workspace" seam so the plugin-host assembler (@rig/core/plugin-host-context)
+ * can trigger Pi skill + package materialization without importing
+ * @rig/provider-plugin (a floor->plugin cycle). The provider plugin owns the
+ * concrete impl (it knows the `.pi/skills` + `.pi/settings.json` layout) and
+ * registers it under {@link SESSION_ASSET_MATERIALIZER}; the assembler resolves
+ * it by id off the project plugin host and calls it. When no provider plugin is
+ * loaded the capability is simply absent and materialization is skipped — the
+ * same non-fatal default the inline implementation had.
+ *
+ * Carries no behaviour and imports only sibling contract types.
+ */
+import type { CapabilityId } from "./capability-id";
+import type { RigConfig } from "./config";
+/** Capability id the provider plugin registers its session-asset materializer under. */
+export declare const SESSION_ASSET_MATERIALIZER_CAPABILITY_ID = "provider.session-asset-materializer";
+/**
+ * Materializes the plugin-contributed session assets (Pi skills declared via
+ * `contributes.skills`, and the config-declared Pi extension packages in
+ * `runtime.pi.packages`) into the project workspace. Idempotent and non-fatal:
+ * implementations log-and-continue on individual write failures so a
+ * materialization error can never deadlock harness boot.
+ */
+export interface SessionAssetMaterializerService {
+    materializeSessionAssets(projectRoot: string, config: RigConfig): Promise<void>;
+}
+/**
+ * Typed capability id the provider plugin provides and the plugin-host assembler
+ * requires. Phantom-typed with `SessionAssetMaterializerService` so `resolve(host)`
+ * returns the service with no cast leaking to callers.
+ */
+export declare const SESSION_ASSET_MATERIALIZER: CapabilityId<SessionAssetMaterializerService>;

package/dist/src/session-asset-materializer.js

@@ -0,0 +1,13 @@
+// @bun
+// packages/contracts/src/capability-id.ts
+function makeCapabilityId(id) {
+  return id;
+}
+
+// packages/contracts/src/session-asset-materializer.ts
+var SESSION_ASSET_MATERIALIZER_CAPABILITY_ID = "provider.session-asset-materializer";
+var SESSION_ASSET_MATERIALIZER = makeCapabilityId(SESSION_ASSET_MATERIALIZER_CAPABILITY_ID);
+export {
+  SESSION_ASSET_MATERIALIZER_CAPABILITY_ID,
+  SESSION_ASSET_MATERIALIZER
+};

package/dist/src/setup.d.ts

@@ -0,0 +1,88 @@
+/**
+ * cap:project-setup — cross-plugin seam.
+ *
+ * `@rig/cli-surface-plugin` (the `rig setup`/onboarding surface) runs project
+ * setup WITHOUT importing `@rig/init-plugin`: it requires this capability by id
+ * off the host. `@rig/init-plugin` OWNS the impl (`runSetup`) and registers it
+ * under this id. This file holds ONLY the pure seam vocabulary — no IO, no
+ * function-laden deps (those are the impl's concern, not the cross-plugin seam).
+ */
+import type { CapabilityId } from "./capability-id";
+import type { GitHubAuthStatus } from "./github";
+/** Capability id the init/setup plugin registers its setup runner under. */
+export declare const PROJECT_SETUP_CAPABILITY_ID = "cap:project-setup";
+/**
+ * Where runs execute for this project. `kind` is the placement discriminator
+ * (e.g. "local" | "remote"); kept as a plain string so contracts stays free of
+ * the placement-domain enum.
+ */
+export type ProjectSetupPlacement = {
+    readonly alias: string;
+    readonly kind: "local" | "remote";
+    readonly host?: string;
+    readonly port?: number;
+    readonly token?: string | null;
+};
+/** Pure input to a project-setup pass. */
+export type ProjectSetupInput = {
+    readonly projectRoot: string;
+    readonly slug: string;
+    readonly placement: ProjectSetupPlacement;
+    readonly rewriteConfig?: boolean;
+    readonly ensurePi?: boolean;
+    readonly ensureLabels?: boolean;
+    readonly githubToken?: string | null;
+    readonly importGhToken?: boolean;
+};
+export type ProjectRepoSlug = {
+    readonly owner: string;
+    readonly repo: string;
+    readonly slug: string;
+};
+export type RigConfigStatus = {
+    readonly exists: boolean;
+    readonly valid: boolean;
+    readonly path: string;
+    readonly slug: string | null;
+    readonly reason?: string;
+};
+export type RigStateStatus = {
+    readonly valid: boolean;
+    readonly selected: string | null;
+    readonly project: string | null;
+    readonly reason?: string;
+};
+export type RigAuthValidation = {
+    readonly ok: boolean;
+    readonly source: "stored-token" | "gh" | "missing";
+    readonly login?: string | null;
+    readonly detail: string;
+    readonly status?: GitHubAuthStatus;
+};
+export type RigSetupStatus = {
+    readonly configured: boolean;
+    readonly projectRoot: string;
+    readonly slug: string | null;
+    readonly config: RigConfigStatus;
+    readonly state: RigStateStatus;
+    readonly auth: RigAuthValidation;
+    readonly reasons: readonly string[];
+};
+export type ProjectSetupResult = {
+    readonly repoSlug: string;
+    readonly placement: string;
+    readonly configWritten: boolean;
+    readonly labels: unknown;
+    readonly pi: unknown;
+    readonly status: RigSetupStatus;
+};
+/** The cohesive project-setup operation the CLI surface depends on. Async methods do IO. */
+export interface ProjectSetupService {
+    parseRepoSlug(value: string): ProjectRepoSlug;
+    detectStartupStatus(input: {
+        readonly projectRoot: string;
+    }): Promise<RigSetupStatus>;
+    runSetup(input: ProjectSetupInput): Promise<ProjectSetupResult>;
+}
+/** Typed capability id; string value is {@link PROJECT_SETUP_CAPABILITY_ID}. */
+export declare const PROJECT_SETUP: CapabilityId<ProjectSetupService>;

package/dist/src/setup.js

@@ -0,0 +1,13 @@
+// @bun
+// packages/contracts/src/capability-id.ts
+function makeCapabilityId(id) {
+  return id;
+}
+
+// packages/contracts/src/setup.ts
+var PROJECT_SETUP_CAPABILITY_ID = "cap:project-setup";
+var PROJECT_SETUP = makeCapabilityId(PROJECT_SETUP_CAPABILITY_ID);
+export {
+  PROJECT_SETUP_CAPABILITY_ID,
+  PROJECT_SETUP
+};

package/dist/src/stage.d.ts

@@ -0,0 +1,245 @@
+import { Schema } from "effect";
+export declare const StageKind: Schema.Literals<readonly ["transform", "gate", "observe"]>;
+export type StageKind = typeof StageKind.Type;
+export declare const StageId: Schema.brand<Schema.Trim, "StageId">;
+export type StageId = typeof StageId.Type;
+export declare const StageContext: Schema.Struct<{
+    readonly runId: Schema.brand<Schema.Trim, "RunId">;
+    readonly taskId: Schema.optional<Schema.NullOr<Schema.brand<Schema.Trim, "TaskId">>>;
+    readonly state: Schema.Unknown;
+    readonly metadata: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+}>;
+export type StageContext = typeof StageContext.Type;
+export declare const StageDescriptor: Schema.Struct<{
+    readonly id: Schema.brand<Schema.Trim, "StageId">;
+    readonly kind: Schema.Literals<readonly ["transform", "gate", "observe"]>;
+    readonly before: Schema.optional<Schema.$Array<Schema.brand<Schema.Trim, "StageId">>>;
+    readonly after: Schema.optional<Schema.$Array<Schema.brand<Schema.Trim, "StageId">>>;
+    readonly priority: Schema.withDecodingDefault<Schema.Number>;
+    readonly protected: Schema.withDecodingDefault<Schema.Boolean>;
+}>;
+export type StageDescriptor = typeof StageDescriptor.Type;
+export declare const Stage: Schema.Struct<{
+    readonly id: Schema.brand<Schema.Trim, "StageId">;
+    readonly kind: Schema.Literals<readonly ["transform", "gate", "observe"]>;
+    readonly before: Schema.optional<Schema.$Array<Schema.brand<Schema.Trim, "StageId">>>;
+    readonly after: Schema.optional<Schema.$Array<Schema.brand<Schema.Trim, "StageId">>>;
+    readonly priority: Schema.withDecodingDefault<Schema.Number>;
+    readonly protected: Schema.withDecodingDefault<Schema.Boolean>;
+}>;
+export type Stage = typeof Stage.Type;
+export declare const StageContinueResult: Schema.Struct<{
+    readonly kind: Schema.Literal<"continue">;
+    readonly ctx: Schema.Struct<{
+        readonly runId: Schema.brand<Schema.Trim, "RunId">;
+        readonly taskId: Schema.optional<Schema.NullOr<Schema.brand<Schema.Trim, "TaskId">>>;
+        readonly state: Schema.Unknown;
+        readonly metadata: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+    }>;
+}>;
+export type StageContinueResult = typeof StageContinueResult.Type;
+export declare const StageAllowResult: Schema.Struct<{
+    readonly kind: Schema.Literal<"allow">;
+}>;
+export type StageAllowResult = typeof StageAllowResult.Type;
+export declare const StageBlockResult: Schema.Struct<{
+    readonly kind: Schema.Literal<"block">;
+    readonly reason: Schema.Trim;
+}>;
+export type StageBlockResult = typeof StageBlockResult.Type;
+export declare const StageResult: Schema.Union<readonly [Schema.Struct<{
+    readonly kind: Schema.Literal<"continue">;
+    readonly ctx: Schema.Struct<{
+        readonly runId: Schema.brand<Schema.Trim, "RunId">;
+        readonly taskId: Schema.optional<Schema.NullOr<Schema.brand<Schema.Trim, "TaskId">>>;
+        readonly state: Schema.Unknown;
+        readonly metadata: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+    }>;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"allow">;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"block">;
+    readonly reason: Schema.Trim;
+}>]>;
+export type StageResult = typeof StageResult.Type;
+export type StageRun = (ctx: StageContext) => Promise<StageResult> | StageResult;
+export declare const StageWrapperDescriptor: Schema.Struct<{
+    readonly id: Schema.Trim;
+    readonly priority: Schema.withDecodingDefault<Schema.Number>;
+}>;
+export type StageWrapperDescriptor = typeof StageWrapperDescriptor.Type;
+export type StageWrapper = (next: StageRun, ctx: StageContext) => Promise<StageResult> | StageResult;
+export declare const StageMutationOp: Schema.Literals<readonly ["insert", "remove", "replace", "wrap", "reorder"]>;
+export type StageMutationOp = typeof StageMutationOp.Type;
+export declare const InsertStageMutation: Schema.Struct<{
+    readonly op: Schema.Literal<"insert">;
+    readonly stage: Schema.Struct<{
+        readonly id: Schema.brand<Schema.Trim, "StageId">;
+        readonly kind: Schema.Literals<readonly ["transform", "gate", "observe"]>;
+        readonly before: Schema.optional<Schema.$Array<Schema.brand<Schema.Trim, "StageId">>>;
+        readonly after: Schema.optional<Schema.$Array<Schema.brand<Schema.Trim, "StageId">>>;
+        readonly priority: Schema.withDecodingDefault<Schema.Number>;
+        readonly protected: Schema.withDecodingDefault<Schema.Boolean>;
+    }>;
+    readonly contributedBy: Schema.optional<Schema.Trim>;
+}>;
+export type InsertStageMutation = typeof InsertStageMutation.Type;
+export declare const RemoveStageMutation: Schema.Struct<{
+    readonly op: Schema.Literal<"remove">;
+    readonly id: Schema.brand<Schema.Trim, "StageId">;
+    readonly contributedBy: Schema.optional<Schema.Trim>;
+}>;
+export type RemoveStageMutation = typeof RemoveStageMutation.Type;
+export declare const ReplaceStageMutation: Schema.Struct<{
+    readonly op: Schema.Literal<"replace">;
+    readonly id: Schema.brand<Schema.Trim, "StageId">;
+    readonly stage: Schema.Struct<{
+        readonly id: Schema.brand<Schema.Trim, "StageId">;
+        readonly kind: Schema.Literals<readonly ["transform", "gate", "observe"]>;
+        readonly before: Schema.optional<Schema.$Array<Schema.brand<Schema.Trim, "StageId">>>;
+        readonly after: Schema.optional<Schema.$Array<Schema.brand<Schema.Trim, "StageId">>>;
+        readonly priority: Schema.withDecodingDefault<Schema.Number>;
+        readonly protected: Schema.withDecodingDefault<Schema.Boolean>;
+    }>;
+    readonly contributedBy: Schema.optional<Schema.Trim>;
+}>;
+export type ReplaceStageMutation = typeof ReplaceStageMutation.Type;
+export declare const WrapStageMutation: Schema.Struct<{
+    readonly op: Schema.Literal<"wrap">;
+    readonly id: Schema.brand<Schema.Trim, "StageId">;
+    readonly around: Schema.Struct<{
+        readonly id: Schema.Trim;
+        readonly priority: Schema.withDecodingDefault<Schema.Number>;
+    }>;
+    readonly contributedBy: Schema.optional<Schema.Trim>;
+}>;
+export type WrapStageMutation = typeof WrapStageMutation.Type;
+export declare const ReorderStageMutation: Schema.Struct<{
+    readonly op: Schema.Literal<"reorder">;
+    readonly id: Schema.brand<Schema.Trim, "StageId">;
+    readonly before: Schema.optional<Schema.$Array<Schema.brand<Schema.Trim, "StageId">>>;
+    readonly after: Schema.optional<Schema.$Array<Schema.brand<Schema.Trim, "StageId">>>;
+    readonly contributedBy: Schema.optional<Schema.Trim>;
+}>;
+export type ReorderStageMutation = typeof ReorderStageMutation.Type;
+export declare const StageMutation: Schema.Union<readonly [Schema.Struct<{
+    readonly op: Schema.Literal<"insert">;
+    readonly stage: Schema.Struct<{
+        readonly id: Schema.brand<Schema.Trim, "StageId">;
+        readonly kind: Schema.Literals<readonly ["transform", "gate", "observe"]>;
+        readonly before: Schema.optional<Schema.$Array<Schema.brand<Schema.Trim, "StageId">>>;
+        readonly after: Schema.optional<Schema.$Array<Schema.brand<Schema.Trim, "StageId">>>;
+        readonly priority: Schema.withDecodingDefault<Schema.Number>;
+        readonly protected: Schema.withDecodingDefault<Schema.Boolean>;
+    }>;
+    readonly contributedBy: Schema.optional<Schema.Trim>;
+}>, Schema.Struct<{
+    readonly op: Schema.Literal<"remove">;
+    readonly id: Schema.brand<Schema.Trim, "StageId">;
+    readonly contributedBy: Schema.optional<Schema.Trim>;
+}>, Schema.Struct<{
+    readonly op: Schema.Literal<"replace">;
+    readonly id: Schema.brand<Schema.Trim, "StageId">;
+    readonly stage: Schema.Struct<{
+        readonly id: Schema.brand<Schema.Trim, "StageId">;
+        readonly kind: Schema.Literals<readonly ["transform", "gate", "observe"]>;
+        readonly before: Schema.optional<Schema.$Array<Schema.brand<Schema.Trim, "StageId">>>;
+        readonly after: Schema.optional<Schema.$Array<Schema.brand<Schema.Trim, "StageId">>>;
+        readonly priority: Schema.withDecodingDefault<Schema.Number>;
+        readonly protected: Schema.withDecodingDefault<Schema.Boolean>;
+    }>;
+    readonly contributedBy: Schema.optional<Schema.Trim>;
+}>, Schema.Struct<{
+    readonly op: Schema.Literal<"wrap">;
+    readonly id: Schema.brand<Schema.Trim, "StageId">;
+    readonly around: Schema.Struct<{
+        readonly id: Schema.Trim;
+        readonly priority: Schema.withDecodingDefault<Schema.Number>;
+    }>;
+    readonly contributedBy: Schema.optional<Schema.Trim>;
+}>, Schema.Struct<{
+    readonly op: Schema.Literal<"reorder">;
+    readonly id: Schema.brand<Schema.Trim, "StageId">;
+    readonly before: Schema.optional<Schema.$Array<Schema.brand<Schema.Trim, "StageId">>>;
+    readonly after: Schema.optional<Schema.$Array<Schema.brand<Schema.Trim, "StageId">>>;
+    readonly contributedBy: Schema.optional<Schema.Trim>;
+}>]>;
+export type StageMutation = typeof StageMutation.Type;
+export declare const ResolutionGrantUse: Schema.Struct<{
+    readonly kind: Schema.Literal<"kernel-replacement">;
+    readonly target: Schema.Trim;
+    readonly pluginId: Schema.Trim;
+}>;
+export type ResolutionGrantUse = typeof ResolutionGrantUse.Type;
+export declare const ResolutionRecordEntry: Schema.Struct<{
+    readonly stageId: Schema.brand<Schema.Trim, "StageId">;
+    readonly contributedBy: Schema.Trim;
+    readonly removedBy: Schema.optional<Schema.Trim>;
+    readonly replacedBy: Schema.optional<Schema.Trim>;
+    readonly wrappedBy: Schema.optional<Schema.$Array<Schema.Trim>>;
+    readonly droppedAnchors: Schema.optional<Schema.$Array<Schema.brand<Schema.Trim, "StageId">>>;
+    readonly isProtected: Schema.Boolean;
+}>;
+export type ResolutionRecordEntry = typeof ResolutionRecordEntry.Type;
+export declare const ResolvedPipeline: Schema.Struct<{
+    readonly runId: Schema.optional<Schema.brand<Schema.Trim, "RunId">>;
+    readonly order: Schema.$Array<Schema.brand<Schema.Trim, "StageId">>;
+    readonly record: Schema.$Array<Schema.Struct<{
+        readonly stageId: Schema.brand<Schema.Trim, "StageId">;
+        readonly contributedBy: Schema.Trim;
+        readonly removedBy: Schema.optional<Schema.Trim>;
+        readonly replacedBy: Schema.optional<Schema.Trim>;
+        readonly wrappedBy: Schema.optional<Schema.$Array<Schema.Trim>>;
+        readonly droppedAnchors: Schema.optional<Schema.$Array<Schema.brand<Schema.Trim, "StageId">>>;
+        readonly isProtected: Schema.Boolean;
+    }>>;
+    readonly cycles: Schema.$Array<Schema.$Array<Schema.brand<Schema.Trim, "StageId">>>;
+    readonly grantUses: Schema.optional<Schema.$Array<Schema.Struct<{
+        readonly kind: Schema.Literal<"kernel-replacement">;
+        readonly target: Schema.Trim;
+        readonly pluginId: Schema.Trim;
+    }>>>;
+    readonly resolvedAt: Schema.optional<Schema.String>;
+}>;
+export type ResolvedPipeline = typeof ResolvedPipeline.Type;
+export declare const ResolutionRecord: Schema.Struct<{
+    readonly runId: Schema.optional<Schema.brand<Schema.Trim, "RunId">>;
+    readonly order: Schema.$Array<Schema.brand<Schema.Trim, "StageId">>;
+    readonly record: Schema.$Array<Schema.Struct<{
+        readonly stageId: Schema.brand<Schema.Trim, "StageId">;
+        readonly contributedBy: Schema.Trim;
+        readonly removedBy: Schema.optional<Schema.Trim>;
+        readonly replacedBy: Schema.optional<Schema.Trim>;
+        readonly wrappedBy: Schema.optional<Schema.$Array<Schema.Trim>>;
+        readonly droppedAnchors: Schema.optional<Schema.$Array<Schema.brand<Schema.Trim, "StageId">>>;
+        readonly isProtected: Schema.Boolean;
+    }>>;
+    readonly cycles: Schema.$Array<Schema.$Array<Schema.brand<Schema.Trim, "StageId">>>;
+    readonly grantUses: Schema.optional<Schema.$Array<Schema.Struct<{
+        readonly kind: Schema.Literal<"kernel-replacement">;
+        readonly target: Schema.Trim;
+        readonly pluginId: Schema.Trim;
+    }>>>;
+    readonly resolvedAt: Schema.optional<Schema.String>;
+}>;
+export type ResolutionRecord = typeof ResolutionRecord.Type;
+export declare const StageRunOutcome: Schema.Struct<{
+    readonly stageId: Schema.brand<Schema.Trim, "StageId">;
+    readonly result: Schema.Union<readonly [Schema.Struct<{
+        readonly kind: Schema.Literal<"continue">;
+        readonly ctx: Schema.Struct<{
+            readonly runId: Schema.brand<Schema.Trim, "RunId">;
+            readonly taskId: Schema.optional<Schema.NullOr<Schema.brand<Schema.Trim, "TaskId">>>;
+            readonly state: Schema.Unknown;
+            readonly metadata: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+        }>;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"allow">;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"block">;
+        readonly reason: Schema.Trim;
+    }>]>;
+    readonly startedAt: Schema.String;
+    readonly finishedAt: Schema.String;
+}>;
+export type StageRunOutcome = typeof StageRunOutcome.Type;

package/dist/src/stage.js

@@ -0,0 +1,169 @@
+// @bun
+// packages/contracts/src/stage.ts
+import { Schema as Schema2 } from "effect";
+
+// packages/contracts/src/baseSchemas.ts
+import { Schema } from "effect";
+var TrimmedString = Schema.Trim;
+var TrimmedNonEmptyString = TrimmedString.check(Schema.isNonEmpty());
+var NonNegativeInt = Schema.Int.check(Schema.isGreaterThanOrEqualTo(0));
+var PositiveInt = Schema.Int.check(Schema.isGreaterThanOrEqualTo(1));
+var IsoDateTime = Schema.String;
+var makeEntityId = (brand) => TrimmedNonEmptyString.pipe(Schema.brand(brand));
+var ThreadId = makeEntityId("ThreadId");
+var ProjectId = makeEntityId("ProjectId");
+var WorkspaceId = makeEntityId("WorkspaceId");
+var GraphId = makeEntityId("GraphId");
+var TaskId = makeEntityId("TaskId");
+var RunId = makeEntityId("RunId");
+var SafePathSegment = TrimmedNonEmptyString.check(Schema.isPattern(/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/)).pipe(Schema.brand("SafePathSegment"));
+var SafeRunId = TrimmedNonEmptyString.check(Schema.isPattern(/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/)).pipe(Schema.brand("SafeRunId"));
+var SafeGitRefComponent = TrimmedNonEmptyString.check(Schema.isPattern(/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/)).pipe(Schema.brand("SafeGitRefComponent"));
+var EngineRuntimeId = makeEntityId("EngineRuntimeId");
+var ConversationId = makeEntityId("ConversationId");
+var ActionId = makeEntityId("ActionId");
+var ArtifactId = makeEntityId("ArtifactId");
+var WorktreeId = makeEntityId("WorktreeId");
+var ValidationResultId = makeEntityId("ValidationResultId");
+var ReviewResultId = makeEntityId("ReviewResultId");
+var CommandId = makeEntityId("CommandId");
+var EventId = makeEntityId("EventId");
+var MessageId = makeEntityId("MessageId");
+var TurnId = makeEntityId("TurnId");
+var ProviderItemId = makeEntityId("ProviderItemId");
+var RuntimeSessionId = makeEntityId("RuntimeSessionId");
+var RuntimeItemId = makeEntityId("RuntimeItemId");
+var RuntimeRequestId = makeEntityId("RuntimeRequestId");
+var RuntimeTaskId = makeEntityId("RuntimeTaskId");
+var ApprovalRequestId = makeEntityId("ApprovalRequestId");
+var CheckpointRef = makeEntityId("CheckpointRef");
+var RemoteEndpointId = makeEntityId("RemoteEndpointId");
+
+// packages/contracts/src/stage.ts
+var StageKind = Schema2.Literals(["transform", "gate", "observe"]);
+var StageId = TrimmedNonEmptyString.pipe(Schema2.brand("StageId"));
+var StageContext = Schema2.Struct({
+  runId: RunId,
+  taskId: Schema2.optional(Schema2.NullOr(TaskId)),
+  state: Schema2.Unknown,
+  metadata: Schema2.optional(Schema2.Record(Schema2.String, Schema2.Unknown))
+});
+var StageDescriptor = Schema2.Struct({
+  id: StageId,
+  kind: StageKind,
+  before: Schema2.optional(Schema2.Array(StageId)),
+  after: Schema2.optional(Schema2.Array(StageId)),
+  priority: Schema2.Number.pipe(Schema2.withDecodingDefault(() => 0)),
+  protected: Schema2.Boolean.pipe(Schema2.withDecodingDefault(() => false))
+});
+var Stage = StageDescriptor;
+var StageContinueResult = Schema2.Struct({
+  kind: Schema2.Literal("continue"),
+  ctx: StageContext
+});
+var StageAllowResult = Schema2.Struct({
+  kind: Schema2.Literal("allow")
+});
+var StageBlockResult = Schema2.Struct({
+  kind: Schema2.Literal("block"),
+  reason: TrimmedNonEmptyString
+});
+var StageResult = Schema2.Union([
+  StageContinueResult,
+  StageAllowResult,
+  StageBlockResult
+]);
+var StageWrapperDescriptor = Schema2.Struct({
+  id: TrimmedNonEmptyString,
+  priority: Schema2.Number.pipe(Schema2.withDecodingDefault(() => 0))
+});
+var StageMutationOp = Schema2.Literals(["insert", "remove", "replace", "wrap", "reorder"]);
+var InsertStageMutation = Schema2.Struct({
+  op: Schema2.Literal("insert"),
+  stage: StageDescriptor,
+  contributedBy: Schema2.optional(TrimmedNonEmptyString)
+});
+var RemoveStageMutation = Schema2.Struct({
+  op: Schema2.Literal("remove"),
+  id: StageId,
+  contributedBy: Schema2.optional(TrimmedNonEmptyString)
+});
+var ReplaceStageMutation = Schema2.Struct({
+  op: Schema2.Literal("replace"),
+  id: StageId,
+  stage: StageDescriptor,
+  contributedBy: Schema2.optional(TrimmedNonEmptyString)
+});
+var WrapStageMutation = Schema2.Struct({
+  op: Schema2.Literal("wrap"),
+  id: StageId,
+  around: StageWrapperDescriptor,
+  contributedBy: Schema2.optional(TrimmedNonEmptyString)
+});
+var ReorderStageMutation = Schema2.Struct({
+  op: Schema2.Literal("reorder"),
+  id: StageId,
+  before: Schema2.optional(Schema2.Array(StageId)),
+  after: Schema2.optional(Schema2.Array(StageId)),
+  contributedBy: Schema2.optional(TrimmedNonEmptyString)
+});
+var StageMutation = Schema2.Union([
+  InsertStageMutation,
+  RemoveStageMutation,
+  ReplaceStageMutation,
+  WrapStageMutation,
+  ReorderStageMutation
+]);
+var ResolutionGrantUse = Schema2.Struct({
+  kind: Schema2.Literal("kernel-replacement"),
+  target: TrimmedNonEmptyString,
+  pluginId: TrimmedNonEmptyString
+});
+var ResolutionRecordEntry = Schema2.Struct({
+  stageId: StageId,
+  contributedBy: TrimmedNonEmptyString,
+  removedBy: Schema2.optional(TrimmedNonEmptyString),
+  replacedBy: Schema2.optional(TrimmedNonEmptyString),
+  wrappedBy: Schema2.optional(Schema2.Array(TrimmedNonEmptyString)),
+  droppedAnchors: Schema2.optional(Schema2.Array(StageId)),
+  isProtected: Schema2.Boolean
+});
+var ResolvedPipeline = Schema2.Struct({
+  runId: Schema2.optional(RunId),
+  order: Schema2.Array(StageId),
+  record: Schema2.Array(ResolutionRecordEntry),
+  cycles: Schema2.Array(Schema2.Array(StageId)),
+  grantUses: Schema2.optional(Schema2.Array(ResolutionGrantUse)),
+  resolvedAt: Schema2.optional(IsoDateTime)
+});
+var ResolutionRecord = ResolvedPipeline;
+var StageRunOutcome = Schema2.Struct({
+  stageId: StageId,
+  result: StageResult,
+  startedAt: IsoDateTime,
+  finishedAt: IsoDateTime
+});
+export {
+  WrapStageMutation,
+  StageWrapperDescriptor,
+  StageRunOutcome,
+  StageResult,
+  StageMutationOp,
+  StageMutation,
+  StageKind,
+  StageId,
+  StageDescriptor,
+  StageContinueResult,
+  StageContext,
+  StageBlockResult,
+  StageAllowResult,
+  Stage,
+  ResolvedPipeline,
+  ResolutionRecordEntry,
+  ResolutionRecord,
+  ResolutionGrantUse,
+  ReplaceStageMutation,
+  ReorderStageMutation,
+  RemoveStageMutation,
+  InsertStageMutation
+};