@h-rig/contracts 0.0.6-alpha.18 → 0.0.6-alpha.181

package/dist/src/task-tracker-state.js

@@ -0,0 +1,39 @@
+// @bun
+// packages/contracts/src/capability-id.ts
+function makeCapabilityId(id) {
+  return id;
+}
+
+// packages/contracts/src/task-tracker-state.ts
+var TASK_TRACKER_LIFECYCLE_STATUSES = [
+  "draft",
+  "open",
+  "ready",
+  "queued",
+  "in_progress",
+  "under_review",
+  "blocked",
+  "completed",
+  "cancelled"
+];
+var TASK_TRACKER_STALE_CLAIM_MS = 24 * 60 * 60 * 1000;
+var TASK_TRACKER_RECONCILIATION_POLICY_CAPABILITY_ID = "lifecycle.task-tracker-reconciliation-policy";
+var TASK_TRACKER_RECONCILIATION_POLICY = makeCapabilityId(TASK_TRACKER_RECONCILIATION_POLICY_CAPABILITY_ID);
+var TASK_TRACKER_READINESS_POLICY_CAPABILITY_ID = "scheduler.task-tracker-readiness-policy";
+var TASK_TRACKER_READINESS_POLICY = makeCapabilityId(TASK_TRACKER_READINESS_POLICY_CAPABILITY_ID);
+var TASK_TRACKER_REPO_LOCATOR_CAPABILITY_ID = "task-state.tracker-repo-locator";
+var TASK_TRACKER_REPO_LOCATOR = makeCapabilityId(TASK_TRACKER_REPO_LOCATOR_CAPABILITY_ID);
+var TASK_TRACKER_STATE_CAPABILITY_ID = "task-state.tracker-state";
+var TASK_TRACKER_STATE = makeCapabilityId(TASK_TRACKER_STATE_CAPABILITY_ID);
+export {
+  TASK_TRACKER_STATE_CAPABILITY_ID,
+  TASK_TRACKER_STATE,
+  TASK_TRACKER_STALE_CLAIM_MS,
+  TASK_TRACKER_REPO_LOCATOR_CAPABILITY_ID,
+  TASK_TRACKER_REPO_LOCATOR,
+  TASK_TRACKER_RECONCILIATION_POLICY_CAPABILITY_ID,
+  TASK_TRACKER_RECONCILIATION_POLICY,
+  TASK_TRACKER_READINESS_POLICY_CAPABILITY_ID,
+  TASK_TRACKER_READINESS_POLICY,
+  TASK_TRACKER_LIFECYCLE_STATUSES
+};

package/dist/src/terminal.d.ts

@@ -0,0 +1,130 @@
+import { Schema } from "effect";
+export declare const DEFAULT_TERMINAL_ID = "default";
+export declare const TerminalThreadInput: Schema.Struct<{
+    readonly threadId: Schema.Trim;
+}>;
+export type TerminalThreadInput = Schema.Codec.Encoded<typeof TerminalThreadInput>;
+declare const TerminalSessionInput: Schema.Struct<{
+    readonly terminalId: Schema.withDecodingDefault<Schema.Trim>;
+    readonly threadId: Schema.Trim;
+}>;
+export type TerminalSessionInput = Schema.Codec.Encoded<typeof TerminalSessionInput>;
+export declare const TerminalOpenInput: Schema.Struct<{
+    readonly cwd: Schema.Trim;
+    readonly cols: Schema.optional<Schema.Int>;
+    readonly rows: Schema.optional<Schema.Int>;
+    readonly env: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
+    readonly terminalId: Schema.withDecodingDefault<Schema.Trim>;
+    readonly threadId: Schema.Trim;
+}>;
+export type TerminalOpenInput = Schema.Codec.Encoded<typeof TerminalOpenInput>;
+export declare const TerminalWriteInput: Schema.Struct<{
+    readonly data: Schema.String;
+    readonly terminalId: Schema.withDecodingDefault<Schema.Trim>;
+    readonly threadId: Schema.Trim;
+}>;
+export type TerminalWriteInput = Schema.Codec.Encoded<typeof TerminalWriteInput>;
+export declare const TerminalResizeInput: Schema.Struct<{
+    readonly cols: Schema.Int;
+    readonly rows: Schema.Int;
+    readonly terminalId: Schema.withDecodingDefault<Schema.Trim>;
+    readonly threadId: Schema.Trim;
+}>;
+export type TerminalResizeInput = Schema.Codec.Encoded<typeof TerminalResizeInput>;
+export declare const TerminalClearInput: Schema.Struct<{
+    readonly terminalId: Schema.withDecodingDefault<Schema.Trim>;
+    readonly threadId: Schema.Trim;
+}>;
+export type TerminalClearInput = Schema.Codec.Encoded<typeof TerminalClearInput>;
+export declare const TerminalRestartInput: Schema.Struct<{
+    readonly cwd: Schema.Trim;
+    readonly cols: Schema.Int;
+    readonly rows: Schema.Int;
+    readonly env: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
+    readonly threadId: Schema.Trim;
+}>;
+export declare const TerminalCloseInput: Schema.Struct<{
+    readonly terminalId: Schema.optional<Schema.Trim>;
+    readonly deleteHistory: Schema.optional<Schema.Boolean>;
+    readonly threadId: Schema.Trim;
+}>;
+export type TerminalCloseInput = Schema.Codec.Encoded<typeof TerminalCloseInput>;
+export declare const TerminalSessionStatus: Schema.Literals<readonly ["starting", "running", "exited", "error"]>;
+export type TerminalSessionStatus = typeof TerminalSessionStatus.Type;
+export declare const TerminalSessionSnapshot: Schema.Struct<{
+    readonly threadId: Schema.String;
+    readonly terminalId: Schema.String;
+    readonly cwd: Schema.String;
+    readonly status: Schema.Literals<readonly ["starting", "running", "exited", "error"]>;
+    readonly pid: Schema.NullOr<Schema.Int>;
+    readonly history: Schema.String;
+    readonly exitCode: Schema.NullOr<Schema.Int>;
+    readonly exitSignal: Schema.NullOr<Schema.String>;
+    readonly updatedAt: Schema.String;
+}>;
+export type TerminalSessionSnapshot = typeof TerminalSessionSnapshot.Type;
+export declare const TerminalEvent: Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.Literal<"started">;
+    readonly snapshot: Schema.Struct<{
+        readonly threadId: Schema.String;
+        readonly terminalId: Schema.String;
+        readonly cwd: Schema.String;
+        readonly status: Schema.Literals<readonly ["starting", "running", "exited", "error"]>;
+        readonly pid: Schema.NullOr<Schema.Int>;
+        readonly history: Schema.String;
+        readonly exitCode: Schema.NullOr<Schema.Int>;
+        readonly exitSignal: Schema.NullOr<Schema.String>;
+        readonly updatedAt: Schema.String;
+    }>;
+    readonly threadId: Schema.String;
+    readonly terminalId: Schema.String;
+    readonly createdAt: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"output">;
+    readonly data: Schema.String;
+    readonly threadId: Schema.String;
+    readonly terminalId: Schema.String;
+    readonly createdAt: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"exited">;
+    readonly exitCode: Schema.NullOr<Schema.Int>;
+    readonly exitSignal: Schema.NullOr<Schema.String>;
+    readonly threadId: Schema.String;
+    readonly terminalId: Schema.String;
+    readonly createdAt: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"error">;
+    readonly message: Schema.String;
+    readonly threadId: Schema.String;
+    readonly terminalId: Schema.String;
+    readonly createdAt: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"cleared">;
+    readonly threadId: Schema.String;
+    readonly terminalId: Schema.String;
+    readonly createdAt: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"restarted">;
+    readonly snapshot: Schema.Struct<{
+        readonly threadId: Schema.String;
+        readonly terminalId: Schema.String;
+        readonly cwd: Schema.String;
+        readonly status: Schema.Literals<readonly ["starting", "running", "exited", "error"]>;
+        readonly pid: Schema.NullOr<Schema.Int>;
+        readonly history: Schema.String;
+        readonly exitCode: Schema.NullOr<Schema.Int>;
+        readonly exitSignal: Schema.NullOr<Schema.String>;
+        readonly updatedAt: Schema.String;
+    }>;
+    readonly threadId: Schema.String;
+    readonly terminalId: Schema.String;
+    readonly createdAt: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"activity">;
+    readonly hasRunningSubprocess: Schema.Boolean;
+    readonly threadId: Schema.String;
+    readonly terminalId: Schema.String;
+    readonly createdAt: Schema.String;
+}>]>;
+export type TerminalEvent = typeof TerminalEvent.Type;
+export {};

package/dist/src/terminal.js

@@ -16,6 +16,9 @@ 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");

package/dist/src/tool-materializer.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Tool-materializer capability seam.
+ *
+ * Defines the TOOL_MATERIALIZER service port that @rig/isolation-plugin
+ * consumes to build the runtime tool binaries (tool gateway, file tools,
+ * claude router, browser tools) without importing @rig/provider-plugin impl
+ * files directly. @rig/provider-plugin provides the capability; isolation-plugin
+ * resolves it via requireInstalledCapability — the SEAM-ONLY replacement for
+ * the four cross-plugin impl imports (§6.4).
+ *
+ * Pure: types + one branded id, no behaviour.
+ */
+import type { CapabilityId } from "./capability-id";
+/**
+ * The tool-materializer service: builds provider-plugin-owned runtime tool
+ * binaries into the given bin directory.
+ */
+export interface ToolMaterializerService {
+    /** Materialize the runtime tool gateway binary. Returns the path. */
+    materializeRuntimeToolGateway(binDir: string): Promise<string>;
+    /** Materialize the runtime file-tools binary. Returns the path. */
+    materializeRuntimeFileTools(targetDir: string): Promise<string>;
+    /** Materialize the Claude tool-router binary. Returns the path. */
+    materializeClaudeToolRouterBinary(projectRoot: string, targetDir: string): Promise<string>;
+    /** Materialize the runtime browser-tools binary. Returns the path. */
+    materializeRuntimeBrowserTools(targetDir: string): Promise<string>;
+    /** Synchronously resolve the runtime browser-tool binary name. */
+    runtimeBrowserToolBinaryName(): string;
+}
+/** Stable id string for the tool-materializer service capability. */
+export declare const TOOL_MATERIALIZER_CAPABILITY_ID = "provider.tool-materializer";
+/**
+ * The branded tool-materializer capability id. `defineCapability(TOOL_MATERIALIZER)`
+ * (provider and consumers independently) resolves to a `ToolMaterializerService`.
+ */
+export declare const TOOL_MATERIALIZER: CapabilityId<ToolMaterializerService>;

package/dist/src/tool-materializer.js

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

package/dist/src/tool-registry.d.ts

@@ -0,0 +1,3 @@
+export declare const RUNTIME_SHELL_TOOL_NAMES: readonly string[];
+export declare const RUNTIME_FILE_TOOL_NAMES: readonly string[];
+export declare const RUNTIME_BROWSER_TOOL_NAMES: readonly string[];

package/dist/src/tool-registry.js

@@ -0,0 +1,58 @@
+// @bun
+// packages/contracts/src/tool-registry.ts
+var RUNTIME_SHELL_TOOL_NAMES = [
+  "bash",
+  "sh",
+  "zsh",
+  "git",
+  "bun",
+  "node",
+  "python3",
+  "rg",
+  "grep",
+  "sed",
+  "cat",
+  "ls",
+  "find",
+  "tsc",
+  "gh",
+  "mkdir",
+  "rm",
+  "mv",
+  "cp",
+  "touch",
+  "pwd",
+  "head",
+  "tail",
+  "wc",
+  "sort",
+  "uniq",
+  "awk",
+  "xargs",
+  "dirname",
+  "basename",
+  "realpath",
+  "env",
+  "jq",
+  "tee",
+  "which"
+];
+var RUNTIME_FILE_TOOL_NAMES = [
+  "rig-read",
+  "rig-write",
+  "rig-edit",
+  "rig-glob",
+  "rig-grep"
+];
+var RUNTIME_BROWSER_TOOL_NAMES = [
+  "rig-browser-launch",
+  "rig-browser-check",
+  "rig-browser-attach-info",
+  "rig-browser-e2e",
+  "rig-browser-reset-profile"
+];
+export {
+  RUNTIME_SHELL_TOOL_NAMES,
+  RUNTIME_FILE_TOOL_NAMES,
+  RUNTIME_BROWSER_TOOL_NAMES
+};

package/dist/src/toolchain-sources.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Toolchain-source contribution seam.
+ *
+ * @rig/isolation-plugin's runtime toolchain materializes per-run hook binaries
+ * (guard hooks, lifecycle hooks) and standalone helper binaries (controlled-bash)
+ * by compiling SOURCE files owned by OTHER plugins. Hardcoding those sibling
+ * `packages/<plugin>/src/...` paths inside the toolchain couples it to every
+ * owning plugin's file layout (and trips the rule-8b arch invariant).
+ *
+ * Instead, each owning plugin CONTRIBUTES its build sources as DATA through a
+ * typed capability id, and the toolchain RESOLVES them off the project's plugin
+ * host. Each contributor owns a DISTINCT capability id (the plugin host enforces
+ * one-provider-per-id, so the two contributors cannot share a single id) — the
+ * toolchain merges the contributions it finds.
+ *
+ * Pure: types + branded ids, no behaviour.
+ */
+import type { CapabilityId } from "./capability-id";
+/**
+ * One per-run hook binary build spec: the binary NAME (the basename the runtime
+ * dispatches by) and its `source` entrypoint, expressed RELATIVE to the rig
+ * source root (the same string the toolchain feeds to `buildBinary`).
+ */
+export interface ToolchainHookBinarySource {
+    readonly name: string;
+    readonly source: string;
+}
+/**
+ * A plugin's contribution of runtime-toolchain build sources.
+ *
+ * - `hookBinaries` are compiled uniformly into the runtime `hooks/` directory
+ *   with the shared hook defines.
+ * - `namedSources` are standalone source paths the toolchain compiles with its
+ *   own per-binary defines, keyed by a stable build id (e.g. `"controlled-bash"`).
+ *
+ * All paths are RELATIVE to the rig source root (unchanged from the literals the
+ * toolchain previously embedded), so resolution behaviour is identical.
+ */
+export interface ToolchainSourceContribution {
+    readonly hookBinaries?: ReadonlyArray<ToolchainHookBinarySource>;
+    readonly namedSources?: Readonly<Record<string, string>>;
+}
+/** Stable id for @rig/guard-plugin's toolchain-source contribution. */
+export declare const GUARD_TOOLCHAIN_SOURCES_CAPABILITY_ID = "rig.toolchain.sources.guard";
+/** Stable id for @rig/lifecycle-plugin's toolchain-source contribution. */
+export declare const LIFECYCLE_TOOLCHAIN_SOURCES_CAPABILITY_ID = "rig.toolchain.sources.lifecycle";
+/**
+ * The guard-plugin toolchain-source capability id. `defineCapability(...)` (the
+ * provider and the isolation-plugin consumer construct it independently from the
+ * shared id) resolves to a `ToolchainSourceContribution`.
+ */
+export declare const GUARD_TOOLCHAIN_SOURCES: CapabilityId<ToolchainSourceContribution>;
+/** The bundle-default-lifecycle toolchain-source capability id. */
+export declare const LIFECYCLE_TOOLCHAIN_SOURCES: CapabilityId<ToolchainSourceContribution>;

package/dist/src/toolchain-sources.js

@@ -0,0 +1,17 @@
+// @bun
+// packages/contracts/src/capability-id.ts
+function makeCapabilityId(id) {
+  return id;
+}
+
+// packages/contracts/src/toolchain-sources.ts
+var GUARD_TOOLCHAIN_SOURCES_CAPABILITY_ID = "rig.toolchain.sources.guard";
+var LIFECYCLE_TOOLCHAIN_SOURCES_CAPABILITY_ID = "rig.toolchain.sources.lifecycle";
+var GUARD_TOOLCHAIN_SOURCES = makeCapabilityId(GUARD_TOOLCHAIN_SOURCES_CAPABILITY_ID);
+var LIFECYCLE_TOOLCHAIN_SOURCES = makeCapabilityId(LIFECYCLE_TOOLCHAIN_SOURCES_CAPABILITY_ID);
+export {
+  LIFECYCLE_TOOLCHAIN_SOURCES_CAPABILITY_ID,
+  LIFECYCLE_TOOLCHAIN_SOURCES,
+  GUARD_TOOLCHAIN_SOURCES_CAPABILITY_ID,
+  GUARD_TOOLCHAIN_SOURCES
+};

package/dist/src/transport-config.d.ts

@@ -0,0 +1,161 @@
+import type { CapabilityId } from "./capability-id";
+export type TransportConfigEnv = Readonly<Record<string, string | undefined>>;
+export declare const DEFAULT_REMOTE_PORT = 7890;
+export type RemoteConfigEntry = {
+    host?: string;
+    port?: number;
+    token?: string;
+    addedAt?: string;
+    lastConnected?: string;
+};
+export type RemotesToml = {
+    version?: number;
+    remotes?: Record<string, RemoteConfigEntry>;
+};
+export type AuthorityRemoteEndpointRecord = {
+    id: string;
+    alias: string;
+    host: string;
+    port: number;
+    transport: string;
+    auto_connect: boolean;
+    labels: string[];
+    capabilities: string[];
+    secret_ref: string;
+    created_at: string;
+    updated_at: string;
+    last_connected_at?: string | null;
+};
+export type AuthorityRemoteEndpointsToml = {
+    version?: number;
+    endpoints?: Record<string, AuthorityRemoteEndpointRecord>;
+};
+export type AuthorityRemoteSecretsToml = {
+    version?: number;
+    secrets?: Record<string, string>;
+};
+export type AuthorityMaterializedRemoteEndpoint = {
+    id: string;
+    alias: string;
+    host: string;
+    port: number;
+    token: string;
+    autoConnect: boolean;
+    addedAt: string;
+    updatedAt: string;
+    lastConnectedAt: string | null;
+    labels: string[];
+    capabilities: string[];
+    transport: string;
+    secretRef: string;
+};
+export type ManagedRemoteEndpoint = {
+    id: string;
+    alias: string;
+    host: string;
+    port: number;
+    token: string;
+    addedAt: string | null;
+    lastConnected: string | null;
+};
+export type RemoteEndpointMigrationResult = {
+    readonly imported: number;
+    readonly skipped: number;
+    readonly sourcePath: string;
+};
+export type RemoteEndpointDoctorResult = {
+    readonly manifestPath: string;
+    readonly secretsPath: string;
+    readonly endpointCount: number;
+    readonly missingSecrets: readonly string[];
+    readonly warnings: readonly string[];
+};
+export type SelectedRemote = {
+    alias: string;
+    host: string;
+    port: number;
+    sshTarget: string;
+    checkout: string | null;
+    registryBaseUrl: string | null;
+    secretRef: string | null;
+};
+export type DispatchTransportPlacement = {
+    readonly kind: "local";
+    readonly alias: "local";
+    readonly sshTarget: null;
+    readonly selected: null;
+} | {
+    readonly kind: "remote";
+    readonly alias: string;
+    readonly sshTarget: string;
+    readonly selected: SelectedRemote | null;
+};
+export interface TransportConfigService {
+    readonly resolveRelayUrl: (input?: {
+        readonly env?: TransportConfigEnv;
+    }) => string;
+    readonly resolveSshTarget: (input?: {
+        readonly env?: TransportConfigEnv;
+    }) => string;
+    readonly listManagedRemoteEndpoints: (input?: {
+        readonly configPath?: string;
+        readonly projectRoot?: string;
+    }) => readonly ManagedRemoteEndpoint[];
+    readonly upsertManagedRemoteEndpoint: (input: {
+        readonly endpoint: {
+            readonly alias: string;
+            readonly host: string;
+            readonly port: number;
+            readonly token?: string;
+        };
+        readonly configPath?: string;
+        readonly projectRoot?: string;
+    }) => ManagedRemoteEndpoint;
+    readonly updateAuthorityRemoteEndpoint: (input: {
+        readonly projectRoot: string;
+        readonly endpoint: {
+            readonly endpointId?: string;
+            readonly alias?: string;
+            readonly host?: string;
+            readonly port?: number;
+            readonly token?: string;
+            readonly autoConnect?: boolean;
+            readonly transport?: string;
+            readonly labels?: readonly string[];
+            readonly capabilities?: readonly string[];
+        };
+    }) => AuthorityMaterializedRemoteEndpoint | null;
+    readonly removeManagedRemoteEndpoint: (input: {
+        readonly alias: string;
+        readonly configPath?: string;
+        readonly projectRoot?: string;
+    }) => boolean;
+    readonly migrateManagedRemoteEndpoints: (input: {
+        readonly projectRoot: string;
+        readonly legacyPath?: string;
+    }) => RemoteEndpointMigrationResult;
+    readonly doctorManagedRemoteEndpoints: (input: {
+        readonly projectRoot: string;
+    }) => RemoteEndpointDoctorResult;
+    readonly resolveSelectedRemote: (input: {
+        readonly projectRoot: string;
+        readonly env?: TransportConfigEnv;
+    }) => SelectedRemote | null;
+    readonly resolveDispatchTransportPlacement: (input: {
+        readonly projectRoot: string;
+        readonly env?: TransportConfigEnv;
+    }) => DispatchTransportPlacement;
+    readonly resolveRegistryBaseUrl: (input: {
+        readonly projectRoot: string;
+        readonly env?: TransportConfigEnv;
+    }) => string;
+    readonly resolveOwnerNamespaceKey: (input: {
+        readonly projectRoot: string;
+        readonly env?: TransportConfigEnv;
+    }) => string | null;
+    readonly resolveRigOmpConfigOverlayPath: (input: {
+        readonly projectRoot: string;
+    }) => string;
+}
+export declare const TRANSPORT_CONFIG_CAPABILITY_ID = "rig.transport.config";
+export declare const TRANSPORT_CONFIG: CapabilityId<TransportConfigService>;

package/dist/src/transport-config.js

@@ -0,0 +1,15 @@
+// @bun
+// packages/contracts/src/capability-id.ts
+function makeCapabilityId(id) {
+  return id;
+}
+
+// packages/contracts/src/transport-config.ts
+var DEFAULT_REMOTE_PORT = 7890;
+var TRANSPORT_CONFIG_CAPABILITY_ID = "rig.transport.config";
+var TRANSPORT_CONFIG = makeCapabilityId(TRANSPORT_CONFIG_CAPABILITY_ID);
+export {
+  TRANSPORT_CONFIG_CAPABILITY_ID,
+  TRANSPORT_CONFIG,
+  DEFAULT_REMOTE_PORT
+};

package/dist/src/validation.d.ts

@@ -0,0 +1,14 @@
+import { Schema } from "effect";
+export declare const ValidationStatus: Schema.Literals<readonly ["pending", "running", "passed", "failed", "skipped"]>;
+export type ValidationStatus = typeof ValidationStatus.Type;
+export declare const ValidationSummary: Schema.Struct<{
+    readonly id: Schema.brand<Schema.Trim, "ValidationResultId">;
+    readonly runId: Schema.brand<Schema.Trim, "RunId">;
+    readonly taskId: Schema.NullOr<Schema.brand<Schema.Trim, "TaskId">>;
+    readonly validatorKey: Schema.Trim;
+    readonly status: Schema.Literals<readonly ["pending", "running", "passed", "failed", "skipped"]>;
+    readonly output: Schema.Unknown;
+    readonly startedAt: Schema.String;
+    readonly completedAt: Schema.NullOr<Schema.String>;
+}>;
+export type ValidationSummary = typeof ValidationSummary.Type;

package/dist/src/validation.js

@@ -16,6 +16,9 @@ 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");