@reasonlayer/sdk 0.0.1

package/node_modules/@reasonlayer/integrations/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { catalog, catalogActionById, resolveCatalogActionDescriptor, slack, } from "./catalog.js";
+export type { CatalogActionDescriptor, CatalogActionId, CatalogActionInput, CatalogActionOutput, CatalogAppId, CatalogJsonSchema, } from "./catalog.js";

package/node_modules/@reasonlayer/integrations/dist/index.js

@@ -0,0 +1 @@
+export { catalog, catalogActionById, resolveCatalogActionDescriptor, slack, } from "./catalog.js";

package/node_modules/@reasonlayer/integrations/dist/internal/definitions.d.ts

@@ -0,0 +1,44 @@
+import * as v from "valibot";
+export type CatalogJsonSchema = Record<string, unknown>;
+declare const catalogActionType: unique symbol;
+export interface CatalogActionDescriptor<InputSchema extends v.GenericSchema = any, OutputSchema extends v.GenericSchema = any, AppId extends string = string, ActionId extends string = string> {
+    (input: v.InferOutput<InputSchema>): Promise<v.InferOutput<OutputSchema>>;
+    readonly [catalogActionType]: true;
+    readonly id: ActionId;
+    readonly appId: AppId;
+    readonly label: string;
+    readonly description: string;
+    readonly version: string;
+    readonly input: InputSchema;
+    readonly output: OutputSchema;
+    readonly inputSchemaJson: CatalogJsonSchema;
+    readonly outputSchemaJson: CatalogJsonSchema;
+}
+export type CatalogActionInput<Action extends CatalogActionDescriptor> = v.InferOutput<Action["input"]>;
+export type CatalogActionOutput<Action extends CatalogActionDescriptor> = v.InferOutput<Action["output"]>;
+export type CatalogActionDefinition = {
+    readonly id: string;
+    readonly label: string;
+    readonly description: string;
+    readonly version: string;
+    readonly input: v.GenericSchema;
+    readonly output: v.GenericSchema;
+};
+type DefinedAction<AppId extends string, Definition extends CatalogActionDefinition> = CatalogActionDescriptor<Definition["input"], Definition["output"], AppId, Definition["id"]>;
+type DefinedActions<AppId extends string, Definitions extends Record<string, CatalogActionDefinition>> = {
+    readonly [Name in keyof Definitions]: DefinedAction<AppId, Definitions[Name]>;
+};
+export type DefinedApp<AppId extends string, Definitions extends Record<string, CatalogActionDefinition>> = {
+    readonly id: AppId;
+    readonly label: string;
+    readonly description: string;
+    readonly actions: DefinedActions<AppId, Definitions>;
+};
+export declare function defineApp<const AppId extends string, const Definitions extends Record<string, CatalogActionDefinition>>(definition: {
+    readonly id: AppId;
+    readonly label: string;
+    readonly description: string;
+    readonly actions: Definitions;
+}): DefinedApp<AppId, Definitions>;
+export declare function isRegisteredCatalogAction(value: unknown): value is CatalogActionDescriptor;
+export {};

package/node_modules/@reasonlayer/integrations/dist/internal/definitions.js

@@ -0,0 +1,52 @@
+import { toJsonSchema } from "@valibot/to-json-schema";
+import * as v from "valibot";
+import { callIntegrationTransport } from "./transport.js";
+const catalogActionRegistryKey = Symbol.for("@reasonlayer/integrations/catalog-actions/v1");
+const catalogGlobal = globalThis;
+const existingCatalogActionRegistry = catalogGlobal[catalogActionRegistryKey];
+const catalogActionRegistry = existingCatalogActionRegistry instanceof WeakSet
+    ? existingCatalogActionRegistry
+    : new WeakSet();
+if (existingCatalogActionRegistry === undefined) {
+    Object.defineProperty(catalogGlobal, catalogActionRegistryKey, {
+        value: catalogActionRegistry,
+    });
+}
+function deepFreeze(value) {
+    if (!value || typeof value !== "object" || Object.isFrozen(value))
+        return;
+    for (const child of Object.values(value))
+        deepFreeze(child);
+    Object.freeze(value);
+}
+function defineAction(definition) {
+    const inputSchemaJson = toJsonSchema(definition.input);
+    const outputSchemaJson = toJsonSchema(definition.output);
+    deepFreeze(inputSchemaJson);
+    deepFreeze(outputSchemaJson);
+    const action = async (input) => {
+        const output = await callIntegrationTransport({
+            actionId: definition.id,
+            input,
+        });
+        return v.parse(definition.output, output);
+    };
+    const descriptor = Object.freeze(Object.assign(action, definition, { inputSchemaJson, outputSchemaJson }));
+    catalogActionRegistry.add(descriptor);
+    return descriptor;
+}
+export function defineApp(definition) {
+    const actions = Object.fromEntries(Object.entries(definition.actions).map(([name, action]) => [
+        name,
+        defineAction({ ...action, appId: definition.id }),
+    ]));
+    return Object.freeze({
+        id: definition.id,
+        label: definition.label,
+        description: definition.description,
+        actions: Object.freeze(actions),
+    });
+}
+export function isRegisteredCatalogAction(value) {
+    return ((typeof value === "object" && value !== null) || typeof value === "function") && catalogActionRegistry.has(value);
+}

package/node_modules/@reasonlayer/integrations/dist/internal/transport.d.ts

@@ -0,0 +1,7 @@
+export interface IntegrationTransportRequest {
+    readonly actionId: string;
+    readonly input: unknown;
+}
+export type IntegrationTransport = (request: IntegrationTransportRequest) => Promise<unknown>;
+export declare function callIntegrationTransport(request: IntegrationTransportRequest): Promise<unknown>;
+export declare function setIntegrationTransportForTests(transport: IntegrationTransport): () => void;

package/node_modules/@reasonlayer/integrations/dist/internal/transport.js

@@ -0,0 +1,48 @@
+import { ConvexHttpClient } from "convex/browser";
+import { makeFunctionReference } from "convex/server";
+const integrationTransportStateKey = Symbol.for("@reasonlayer/integrations/transport-state/v1");
+const integrationGlobal = globalThis;
+const existingIntegrationTransportState = integrationGlobal[integrationTransportStateKey];
+const integrationTransportState = existingIntegrationTransportState &&
+    typeof existingIntegrationTransportState === "object"
+    ? existingIntegrationTransportState
+    : {};
+if (existingIntegrationTransportState === undefined) {
+    Object.defineProperty(integrationGlobal, integrationTransportStateKey, {
+        value: integrationTransportState,
+    });
+}
+const invokeIntegration = makeFunctionReference("integrations:invokeIntegration");
+async function defaultIntegrationTransport(request) {
+    const convexUrl = process.env["RL_CONVEX_URL"];
+    const taskId = process.env["RL_TASK_ID"];
+    const taskToken = process.env["RL_TASK_TOKEN"];
+    if (!convexUrl || !taskId || !taskToken) {
+        throw new Error("integration calls only work inside a running Reasonlayer step");
+    }
+    const client = new ConvexHttpClient(convexUrl, {
+        logger: false,
+        skipConvexDeploymentUrlCheck: true,
+    });
+    return await client.action(invokeIntegration, {
+        taskId,
+        taskToken,
+        actionId: request.actionId,
+        input: request.input,
+    });
+}
+export async function callIntegrationTransport(request) {
+    return await (integrationTransportState.override ?? defaultIntegrationTransport)(request);
+}
+export function setIntegrationTransportForTests(transport) {
+    const previous = integrationTransportState.override;
+    integrationTransportState.override = transport;
+    return () => {
+        if (integrationTransportState.override !== transport)
+            return;
+        if (previous === undefined)
+            delete integrationTransportState.override;
+        else
+            integrationTransportState.override = previous;
+    };
+}

package/node_modules/@reasonlayer/integrations/dist/testkit.d.ts

@@ -0,0 +1 @@
+export { setIntegrationTransportForTests as setIntegrationTransport, type IntegrationTransport, type IntegrationTransportRequest, } from "./internal/transport.js";

package/node_modules/@reasonlayer/integrations/dist/testkit.js

@@ -0,0 +1 @@
+export { setIntegrationTransportForTests as setIntegrationTransport, } from "./internal/transport.js";

package/node_modules/@reasonlayer/integrations/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@reasonlayer/integrations",
+  "version": "0.1.0",
+  "private": true,
+  "license": "Apache-2.0",
+  "type": "module",
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./testkit": {
+      "types": "./dist/testkit.d.ts",
+      "import": "./dist/testkit.js"
+    }
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "codegen": "node scripts/generate-catalog.mjs",
+    "test": "vitest run",
+    "typecheck": "tsc -p tsconfig.json --noEmit"
+  }
+}

package/node_modules/@reasonlayer/protocol/dist/dispatch.d.ts

@@ -0,0 +1,10 @@
+export declare const DISPATCH_SIGNATURE_SKEW_MS: number;
+export declare const DISPATCH_TIMESTAMP_HEADER = "x-rl-timestamp";
+export declare const DISPATCH_SIGNATURE_HEADER = "x-rl-signature";
+export type DispatchHeaders = {
+    get(name: string): string | null | undefined;
+} | Record<string, string | string[] | undefined>;
+export declare function signDispatchBody(secret: string, timestamp: string, body: string): Promise<string>;
+export declare function signDispatchRequest(secret: string, body: string, timestamp?: string): Promise<Record<string, string>>;
+export declare function verifyDispatchSignature(secret: string, timestamp: string, body: string, signature: string, now?: number): Promise<boolean>;
+export declare function verifyDispatchRequest(headers: DispatchHeaders, body: string, secret: string, now?: number): Promise<boolean>;

package/node_modules/@reasonlayer/protocol/dist/dispatch.js

@@ -0,0 +1,58 @@
+export const DISPATCH_SIGNATURE_SKEW_MS = 5 * 60 * 1000;
+export const DISPATCH_TIMESTAMP_HEADER = "x-rl-timestamp";
+export const DISPATCH_SIGNATURE_HEADER = "x-rl-signature";
+const encoder = new TextEncoder();
+function subtleCrypto() {
+    const cryptoObject = globalThis.crypto;
+    if (!cryptoObject?.subtle) {
+        throw new Error("Web Crypto HMAC is not available in this runtime");
+    }
+    return cryptoObject.subtle;
+}
+function bytesToHex(bytes) {
+    return [...new Uint8Array(bytes)]
+        .map((byte) => byte.toString(16).padStart(2, "0"))
+        .join("");
+}
+function constantTimeEqual(a, b) {
+    if (a.length !== b.length)
+        return false;
+    let diff = 0;
+    for (let i = 0; i < a.length; i += 1) {
+        diff |= a.charCodeAt(i) ^ b.charCodeAt(i);
+    }
+    return diff === 0;
+}
+function headerValue(headers, name) {
+    if ("get" in headers && typeof headers.get === "function") {
+        return headers.get(name) ?? undefined;
+    }
+    const record = headers;
+    const direct = record[name] ?? record[name.toLowerCase()];
+    return Array.isArray(direct) ? direct[0] : direct;
+}
+export async function signDispatchBody(secret, timestamp, body) {
+    const key = await subtleCrypto().importKey("raw", encoder.encode(secret), { name: "HMAC", hash: "SHA-256" }, false, ["sign"]);
+    return bytesToHex(await subtleCrypto().sign("HMAC", key, encoder.encode(`${timestamp}.${body}`)));
+}
+export async function signDispatchRequest(secret, body, timestamp = Date.now().toString()) {
+    return {
+        [DISPATCH_TIMESTAMP_HEADER]: timestamp,
+        [DISPATCH_SIGNATURE_HEADER]: await signDispatchBody(secret, timestamp, body),
+    };
+}
+export async function verifyDispatchSignature(secret, timestamp, body, signature, now = Date.now()) {
+    const numeric = Number(timestamp);
+    if (!Number.isFinite(numeric) || Math.abs(now - numeric) > DISPATCH_SIGNATURE_SKEW_MS) {
+        return false;
+    }
+    const expected = await signDispatchBody(secret, timestamp, body);
+    return constantTimeEqual(signature, expected);
+}
+export async function verifyDispatchRequest(headers, body, secret, now = Date.now()) {
+    const timestamp = headerValue(headers, DISPATCH_TIMESTAMP_HEADER);
+    const signature = headerValue(headers, DISPATCH_SIGNATURE_HEADER);
+    if (!timestamp || !signature)
+        return false;
+    return await verifyDispatchSignature(secret, timestamp, body, signature, now);
+}

package/node_modules/@reasonlayer/protocol/dist/envelope.d.ts

@@ -0,0 +1,9 @@
+/** Stable organization identifier carried across context boundaries. */
+export type OrgId = string;
+/** The context-neutral portion of an append-only domain event. */
+export interface EventEnvelope<TType extends string = string> {
+    id: string;
+    org: OrgId;
+    time: number;
+    type: TType;
+}

package/node_modules/@reasonlayer/protocol/dist/envelope.js

@@ -0,0 +1 @@
+export {};

package/node_modules/@reasonlayer/protocol/dist/environments.d.ts

@@ -0,0 +1,7 @@
+/**
+ * The production Convex deployment. Compiled into every consumer (CLI,
+ * backend) deliberately: repointing production is a reviewed code change and
+ * a release, never a runtime input. Dev/E2E deployments are injected via
+ * RL_CONVEX_URL by generated tooling and are not listed here.
+ */
+export declare const PRODUCTION_CONVEX_URL = "https://patient-meerkat-744.convex.cloud";

package/node_modules/@reasonlayer/protocol/dist/environments.js

@@ -0,0 +1,7 @@
+/**
+ * The production Convex deployment. Compiled into every consumer (CLI,
+ * backend) deliberately: repointing production is a reviewed code change and
+ * a release, never a runtime input. Dev/E2E deployments are injected via
+ * RL_CONVEX_URL by generated tooling and are not listed here.
+ */
+export const PRODUCTION_CONVEX_URL = "https://patient-meerkat-744.convex.cloud";

package/node_modules/@reasonlayer/protocol/dist/events.d.ts

@@ -0,0 +1,313 @@
+import type { HostIR, ReviewViewIR } from "./ir.js";
+export type RunFinishedStatus = "succeeded" | "succeeded_with_failures" | "failed" | "canceled";
+export type RunStatus = "running" | "waiting_for_review" | RunFinishedStatus;
+export declare function isTerminalRunStatus(status: string): status is RunFinishedStatus;
+export type RunCause = {
+    kind: "trigger";
+    trigger: string;
+    versionId: string;
+} | {
+    kind: "manual";
+    actor: string;
+    versionId: string;
+} | {
+    kind: "retry";
+    ofRunId: string;
+    actor: string;
+};
+export type TaskClaimant = {
+    kind: "sandbox" | "device" | "executor";
+    id: string;
+};
+/**
+ * The V2 launch vocabulary. Payloads are deliberately complete for readers;
+ * emitters do not reach into Review, Alerting, or Billing directly.
+ */
+export type LifecycleEvent = {
+    type: "run.created";
+    payload: {
+        cause: RunCause;
+        input: unknown;
+        runKey?: string;
+    };
+} | {
+    type: "run.finished";
+    payload: {
+        status: RunFinishedStatus;
+        error?: string;
+    };
+} | {
+    type: "run.retried";
+    payload: {
+        actor: string;
+    };
+} | {
+    type: "step.started";
+    payload: {
+        stepId: string;
+        invocationKey: string;
+        attempt: number;
+    };
+} | {
+    type: "step.expanded";
+    payload: {
+        stepId: string;
+        childrenTotal: number;
+    };
+} | {
+    type: "step.succeeded";
+    payload: {
+        stepId: string;
+        invocationKey: string;
+        attempt: number;
+    };
+} | {
+    type: "step.failed";
+    payload: {
+        stepId: string;
+        invocationKey: string;
+        attempt: number;
+        error: string;
+    };
+} | {
+    type: "step.skipped";
+    payload: {
+        stepId: string;
+        reason: string;
+    };
+} | {
+    type: "step.canceled";
+    payload: {
+        stepId: string;
+        invocationKey: string;
+        scope: "run" | "step";
+    };
+} | {
+    type: "task.created";
+    payload: {
+        taskId: string;
+        stepId: string;
+        invocationKey: string;
+        attempt: number;
+        host: HostIR;
+    };
+} | {
+    type: "task.dispatched";
+    payload: {
+        taskId: string;
+        host: HostIR;
+    };
+} | {
+    type: "task.spawned";
+    payload: {
+        taskId: string;
+        sandboxId: string;
+    };
+} | {
+    type: "task.claimed";
+    payload: {
+        taskId: string;
+        claimant: TaskClaimant;
+    };
+} | {
+    type: "task.completed";
+    payload: {
+        taskId: string;
+        result: "ok" | "error";
+        error?: string;
+    };
+} | {
+    type: "task.timeout";
+    payload: {
+        taskId: string;
+        attempt: number;
+    };
+} | {
+    type: "task.canceled";
+    payload: {
+        taskId: string;
+        scope: "run" | "step";
+    };
+} | {
+    type: "task.redispatched";
+    payload: {
+        taskId: string;
+    };
+} | {
+    type: "review.requested";
+    payload: {
+        reviewId: string;
+        runId: string;
+        stepId: string;
+        invocationKey: string;
+        attempt: number;
+        contentRef: {
+            kind: "reviewContent";
+            contentId: string;
+        } | {
+            kind: "approval";
+            approvalId: string;
+        };
+        view: ReviewViewIR;
+        outputSchemaJson: string;
+        originalContentHash: string;
+        deadlineAt: number;
+    };
+} | {
+    type: "review.decided";
+    payload: {
+        reviewId: string;
+        decision: "approved" | "rejected";
+        actor: string;
+        edited: boolean;
+    };
+} | {
+    type: "review.expired";
+    payload: {
+        reviewId: string;
+    };
+} | {
+    type: "review.canceled";
+    payload: {
+        reviewId: string;
+        reason: string;
+    };
+} | {
+    type: "usage.recorded";
+    payload: {
+        runId: string;
+        stepId: string;
+        invocationKey: string;
+        attempt: number;
+        model?: string;
+        inputTokens: number;
+        outputTokens: number;
+        costUsd: number;
+    };
+} | {
+    type: "workspace.session_started";
+    payload: {
+        workflowId: string;
+        sessionId: string;
+        actor: string;
+        machineLabel: string;
+    };
+} | {
+    type: "workspace.session_ended";
+    payload: {
+        workflowId: string;
+        sessionId: string;
+        reason: "done" | "expired";
+    };
+} | {
+    type: "trigger.fired";
+    payload: {
+        workflowId: string;
+        trigger: string;
+        versionId: string;
+        scheduledFor: number;
+        runId: string;
+    };
+} | {
+    type: "trigger.reconciled";
+    payload: {
+        workflowId: string;
+        versionId: string;
+        created: string[];
+        kept: string[];
+        retired: string[];
+    };
+} | {
+    type: "variables.set";
+    payload: {
+        name: string;
+        value: unknown;
+        actor: string;
+    };
+} | {
+    type: "variables.removed";
+    payload: {
+        name: string;
+        actor: string;
+    };
+} | {
+    type: "version.published";
+    payload: {
+        workflowId: string;
+        versionId: string;
+        versionNumber: number;
+        actor: string;
+        cause: "publish" | "rollback";
+    };
+};
+export type LifecycleEventType = LifecycleEvent["type"];
+export type LifecycleEventOf<T extends LifecycleEventType> = Extract<LifecycleEvent, {
+    type: T;
+}>;
+export declare const LIFECYCLE_EVENT_TYPES: readonly ["run.created", "run.finished", "run.retried", "step.started", "step.expanded", "step.succeeded", "step.failed", "step.skipped", "step.canceled", "task.created", "task.dispatched", "task.spawned", "task.claimed", "task.completed", "task.timeout", "task.canceled", "task.redispatched", "review.requested", "review.decided", "review.expired", "review.canceled", "usage.recorded", "workspace.session_started", "workspace.session_ended", "trigger.fired", "trigger.reconciled", "variables.set", "variables.removed", "version.published"];
+/**
+ * The typed agent transcript model. These high-volume observations are not
+ * lifecycle events and remain in `agentEvents`.
+ */
+export interface AgentStepUsage {
+    model?: string;
+    inputTokens: number;
+    outputTokens: number;
+    costUsd: number;
+}
+export type AgentEventLevel = "debug" | "info" | "warn" | "error";
+interface AgentEventBase {
+    seq: number;
+    turnSeq?: number;
+    level: AgentEventLevel;
+    ts: number;
+}
+export interface AgentTurnEvent extends AgentEventBase {
+    type: "agent.turn";
+    data: {
+        model?: string;
+        text?: string;
+        finishReason?: string;
+        purpose?: "agent" | "compaction";
+        usage: AgentStepUsage;
+    };
+}
+export interface AgentToolEvent extends AgentEventBase {
+    type: "agent.tool";
+    data: {
+        toolName: string;
+        args?: unknown;
+        result?: unknown;
+        ok: boolean;
+        durationMs: number;
+    };
+}
+/** A collapsed subagent delegation (flat siblings, not a tree — named ceiling, spec §8.2). */
+export interface AgentTaskEvent extends AgentEventBase {
+    type: "agent.task";
+    data: {
+        agent?: string;
+        prompt?: string;
+        result?: unknown;
+        ok: boolean;
+        durationMs: number;
+        usage: AgentStepUsage;
+    };
+}
+export interface AgentLogEvent extends AgentEventBase {
+    type: "agent.log";
+    data: {
+        message: string;
+        fields?: Record<string, unknown>;
+    };
+}
+/** Exactly one per terminally-failed step — in addition to, never instead of, the task result. */
+export interface AgentErrorEvent extends AgentEventBase {
+    type: "agent.error";
+    data: {
+        message: string;
+        kind?: string;
+    };
+}
+export type AgentEvent = AgentTurnEvent | AgentToolEvent | AgentTaskEvent | AgentLogEvent | AgentErrorEvent;
+export {};

package/node_modules/@reasonlayer/protocol/dist/events.js

@@ -0,0 +1,20 @@
+const TERMINAL_RUN_STATUSES = new Set([
+    "succeeded",
+    "succeeded_with_failures",
+    "failed",
+    "canceled",
+]);
+export function isTerminalRunStatus(status) {
+    return TERMINAL_RUN_STATUSES.has(status);
+}
+export const LIFECYCLE_EVENT_TYPES = [
+    "run.created", "run.finished", "run.retried",
+    "step.started", "step.expanded", "step.succeeded", "step.failed", "step.skipped", "step.canceled",
+    "task.created", "task.dispatched", "task.spawned", "task.claimed", "task.completed", "task.timeout", "task.canceled", "task.redispatched",
+    "review.requested", "review.decided", "review.expired", "review.canceled",
+    "usage.recorded",
+    "workspace.session_started", "workspace.session_ended",
+    "trigger.fired", "trigger.reconciled",
+    "variables.set", "variables.removed",
+    "version.published",
+];

package/node_modules/@reasonlayer/protocol/dist/index.d.ts

@@ -0,0 +1,18 @@
+export type { JsonSchema, SelectorIR, RetryPolicyIR, SecretRefIR, VariableIR, DeviceRefIR, LocalMcpServerIR, RemoteMcpServerIR, McpServerIR, EnvironmentFileIR, EnvironmentIR, EnvironmentStatusKind, EnvironmentMcpToolInventory, EnvironmentProvenance, EnvironmentStatus, EnvironmentDeclaration, HostIR, ReviewViewIR, CodeStepIR, AgentStepIR, ReviewStepIR, ActionStepIR, MapChildStepIR, MapStepIR, StepIR, TriggerIR, WorkflowIR, } from "./ir.js";
+export { STEP_ID_PATTERN, VARIABLE_NAME_PATTERN, mapChildId, isCloudHostedStep, executableStepEnvironment, collectWorkflowEnvironments, stableJson, environmentDeclaration, canonicalEnvironmentDeclarationJson, mcpUrlEnvName, shellQuote, parseExactNpmPackage, parseExactPipPackage, executableNameFromPackageName, executableNameFromNpmSpec, executableNameFromPipSpec, firstCommandToken, declaredEnvironmentExecutables, } from "./ir.js";
+export type { ParsedNpmPackage, ParsedPipPackage } from "./ir.js";
+export type { TaskKind, TaskStatus, StepLocator, CodeTaskSpec, AgentTaskSpec, ActionTaskSpec, TaskSpec, TaskResult, TaskEvent, } from "./tasks.js";
+export type { LifecycleEvent, LifecycleEventType, LifecycleEventOf, RunStatus, RunFinishedStatus, RunCause, TaskClaimant, AgentStepUsage, AgentEventLevel, AgentEvent, AgentTurnEvent, AgentToolEvent, AgentTaskEvent, AgentLogEvent, AgentErrorEvent, } from "./events.js";
+export { LIFECYCLE_EVENT_TYPES, isTerminalRunStatus } from "./events.js";
+export { evaluateSelector, getPath, referencedStepIds, usesMapItem, SelectorEvalError, } from "./selector.js";
+export type { SelectorContext } from "./selector.js";
+export { validateAgainstSchema } from "./validate.js";
+export { collapseMapChildren, dependencyBlockers, doomedSteps, stepDependencies, isTerminalStepRunStatus, readySteps, workflowOutputBlockers, workflowOutputReady, workflowStepsComplete, expandMapStep, evaluateStepInput, evaluateWorkflowOutput, } from "./scheduling.js";
+export type { DependencyBlocker, InputStep, MapChildResult, MapCollapseResult, MapExpansionItem, BlockingStepRunStatus, StepRunState, StepRunStatus, } from "./scheduling.js";
+export { FN, LEASE_DEFAULT_MS, LEASE_FLOOR_MS } from "./runtime.js";
+export type { FnName } from "./runtime.js";
+export { ALERT_KINDS, APPROVAL_STATUSES } from "./readmodels.js";
+export type { RunMode, RunTrigger, RunReadModel, RunListRow, RunStepUsageRow, RunUsageReadModel, RunInspectionStep, RunInspectionApproval, RunLifecycleEventRow, RunInspection, TranscriptEventType, TranscriptEvent, TranscriptPage, ApprovalStatus, ActorIdentity, ApprovalReadModel, WorkflowPublishState, WorkflowCompileStatus, WorkflowHealthRow, WorkflowListRow, WorkflowGroupRow, AuthoringSessionRow, WorkspaceStatus, WorkflowConsoleDetail, WorkflowVersionRow, WorkspaceBundleRow, DeploymentReadModel, LatestDeploymentRef, TriggerScheduleReadModel, WorkflowVariableRow, SecretReadModel, PlatformTokenReadModel, IntegrationConnectionState, IntegrationCatalogAction, IntegrationCatalogApp, IntegrationConnectionReadModel, AlertKind, AlertLifecycle, AlertPolicyScope, AlertMemberIdentity, AlertChainRung, AlertNotificationRow, AlertNotification, AlertReadModel, AlertPolicyReadModel, SlackIntegrationReadModel, ShellCounts, AlertSummaryRow, HomeOverview, WorkflowHealthPage, MemberRole, ActorKind, OrgActor, OrgReadModel, MemberReadModel, OrgMembershipRow, SessionReadModel, DeviceReadModel, DeviceProfileLoginState, DeviceProfileReadModel, InvitationReadModel, } from "./readmodels.js";
+export { PERMISSIONS } from "./permissions.js";
+export type { Permission, Scope } from "./permissions.js";
+export { PRODUCTION_CONVEX_URL } from "./environments.js";

package/node_modules/@reasonlayer/protocol/dist/index.js

@@ -0,0 +1,9 @@
+export { STEP_ID_PATTERN, VARIABLE_NAME_PATTERN, mapChildId, isCloudHostedStep, executableStepEnvironment, collectWorkflowEnvironments, stableJson, environmentDeclaration, canonicalEnvironmentDeclarationJson, mcpUrlEnvName, shellQuote, parseExactNpmPackage, parseExactPipPackage, executableNameFromPackageName, executableNameFromNpmSpec, executableNameFromPipSpec, firstCommandToken, declaredEnvironmentExecutables, } from "./ir.js";
+export { LIFECYCLE_EVENT_TYPES, isTerminalRunStatus } from "./events.js";
+export { evaluateSelector, getPath, referencedStepIds, usesMapItem, SelectorEvalError, } from "./selector.js";
+export { validateAgainstSchema } from "./validate.js";
+export { collapseMapChildren, dependencyBlockers, doomedSteps, stepDependencies, isTerminalStepRunStatus, readySteps, workflowOutputBlockers, workflowOutputReady, workflowStepsComplete, expandMapStep, evaluateStepInput, evaluateWorkflowOutput, } from "./scheduling.js";
+export { FN, LEASE_DEFAULT_MS, LEASE_FLOOR_MS } from "./runtime.js";
+export { ALERT_KINDS, APPROVAL_STATUSES } from "./readmodels.js";
+export { PERMISSIONS } from "./permissions.js";
+export { PRODUCTION_CONVEX_URL } from "./environments.js";