automate.ax 0.1.3

package/dist/automation/integrations.d.ts

@@ -0,0 +1,63 @@
+export type IntegrationScopeRequirement = ScopeRequirementGroup | string;
+/** A recursive group of integration scope requirements. */
+export interface ScopeRequirementGroup {
+    requirements: IntegrationScopeRequirement[];
+    type: "and" | "or";
+}
+/** Combinators for declaring recursive integration scope requirements. */
+export declare const scope: {
+    /**
+     * Requires every scope or nested group.
+     *
+     * @param requirements - Required scopes and nested groups.
+     */
+    all(...requirements: IntegrationScopeRequirement[]): ScopeRequirementGroup;
+    /**
+     * Requires any scope or nested group.
+     *
+     * Alternatives must be ordered from most permissive to least permissive.
+     *
+     * @param requirements - Alternative scopes and nested groups.
+     */
+    any(...requirements: IntegrationScopeRequirement[]): ScopeRequirementGroup;
+};
+export declare const actionAccountRequirementDefinition: unique symbol;
+export declare const integrationAccountDefinition: unique symbol;
+export declare const DEFAULT_ACCOUNT_BINDING = "default";
+export declare const serializedIntegrationAccountDefinition = "$integrationAccount";
+/** An action whose account requirement can contribute authorization scopes. */
+export interface AccountAuthorizationAction<TServiceId extends string> {
+    readonly [actionAccountRequirementDefinition]: {
+        requiredScopes: IntegrationScopeRequirement[];
+        serviceId: TServiceId;
+    };
+}
+export type AccountAuthorizationHint<TServiceId extends string> = AccountAuthorizationAction<TServiceId> | IntegrationScopeRequirement;
+/** An opaque reference to a stable project account binding. */
+export interface IntegrationAccountReference<TServiceId extends string = string> {
+    readonly [serializedIntegrationAccountDefinition]: {
+        binding: string;
+        serviceId: TServiceId;
+    };
+    readonly [integrationAccountDefinition]: {
+        binding: string;
+        serviceId: TServiceId;
+    };
+}
+export interface ResolvedIntegrationAccount<TServiceId extends string = string> {
+    secret: Record<string, unknown>;
+    serviceId: TServiceId;
+}
+/**
+ * Defines the account declaration function for one integration service.
+ *
+ * @param serviceId - Stable integration service identifier.
+ */
+export declare function defineAccount<const TServiceId extends string>(serviceId: TServiceId): (binding: string, authorizationHints?: AccountAuthorizationHint<TServiceId>[]) => IntegrationAccountReference<TServiceId>;
+/**
+ * Determines whether a runtime value is an integration account reference.
+ *
+ * @param value - Materialized action input value to inspect.
+ */
+export declare function isIntegrationAccountReference(value: unknown): value is IntegrationAccountReference;
+//# sourceMappingURL=integrations.d.ts.map

package/dist/automation/integrations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"integrations.d.ts","sourceRoot":"","sources":["../../src/automation/integrations.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,2BAA2B,GAAG,qBAAqB,GAAG,MAAM,CAAA;AAExE,2DAA2D;AAC3D,MAAM,WAAW,qBAAqB;IACpC,YAAY,EAAE,2BAA2B,EAAE,CAAA;IAC3C,IAAI,EAAE,KAAK,GAAG,IAAI,CAAA;CACnB;AAED,0EAA0E;AAC1E,eAAO,MAAM,KAAK;IAChB;;;;OAIG;yBACkB,2BAA2B,EAAE,GAAG,qBAAqB;IAI1E;;;;;;OAMG;yBACkB,2BAA2B,EAAE,GAAG,qBAAqB;CAG3E,CAAA;AAED,eAAO,MAAM,kCAAkC,EAAE,OAAO,MAEvD,CAAA;AACD,eAAO,MAAM,4BAA4B,EAAE,OAAO,MAEjD,CAAA;AACD,eAAO,MAAM,uBAAuB,YAAY,CAAA;AAChD,eAAO,MAAM,sCAAsC,wBAAwB,CAAA;AAE3E,+EAA+E;AAC/E,MAAM,WAAW,0BAA0B,CAAC,UAAU,SAAS,MAAM;IACnE,QAAQ,CAAC,CAAC,kCAAkC,CAAC,EAAE;QAC7C,cAAc,EAAE,2BAA2B,EAAE,CAAA;QAC7C,SAAS,EAAE,UAAU,CAAA;KACtB,CAAA;CACF;AAED,MAAM,MAAM,wBAAwB,CAAC,UAAU,SAAS,MAAM,IAC1D,0BAA0B,CAAC,UAAU,CAAC,GACtC,2BAA2B,CAAA;AAE/B,+DAA+D;AAC/D,MAAM,WAAW,2BAA2B,CAC1C,UAAU,SAAS,MAAM,GAAG,MAAM;IAElC,QAAQ,CAAC,CAAC,sCAAsC,CAAC,EAAE;QACjD,OAAO,EAAE,MAAM,CAAA;QACf,SAAS,EAAE,UAAU,CAAA;KACtB,CAAA;IACD,QAAQ,CAAC,CAAC,4BAA4B,CAAC,EAAE;QACvC,OAAO,EAAE,MAAM,CAAA;QACf,SAAS,EAAE,UAAU,CAAA;KACtB,CAAA;CACF;AAED,MAAM,WAAW,0BAA0B,CACzC,UAAU,SAAS,MAAM,GAAG,MAAM;IAElC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC/B,SAAS,EAAE,UAAU,CAAA;CACtB;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,KAAK,CAAC,UAAU,SAAS,MAAM,EAC3D,SAAS,EAAE,UAAU,IAGnB,SAAS,MAAM,EACf,qBAAqB,wBAAwB,CAAC,UAAU,CAAC,EAAE,KAC1D,2BAA2B,CAAC,UAAU,CAAC,CAmB3C;AAED;;;;GAIG;AACH,wBAAgB,6BAA6B,CAC3C,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,2BAA2B,CAMtC"}

package/dist/automation/integrations.js

@@ -0,0 +1,58 @@
+/** Combinators for declaring recursive integration scope requirements. */
+export const scope = {
+    /**
+     * Requires every scope or nested group.
+     *
+     * @param requirements - Required scopes and nested groups.
+     */
+    all(...requirements) {
+        return { requirements: [...new Set(requirements)], type: "and" };
+    },
+    /**
+     * Requires any scope or nested group.
+     *
+     * Alternatives must be ordered from most permissive to least permissive.
+     *
+     * @param requirements - Alternative scopes and nested groups.
+     */
+    any(...requirements) {
+        return { requirements: [...new Set(requirements)], type: "or" };
+    },
+};
+export const actionAccountRequirementDefinition = Symbol("automation.actionAccountRequirementDefinition");
+export const integrationAccountDefinition = Symbol("automation.integrationAccountDefinition");
+export const DEFAULT_ACCOUNT_BINDING = "default";
+export const serializedIntegrationAccountDefinition = "$integrationAccount";
+/**
+ * Defines the account declaration function for one integration service.
+ *
+ * @param serviceId - Stable integration service identifier.
+ */
+export function defineAccount(serviceId) {
+    return (binding, authorizationHints) => {
+        globalThis.__AUTOMATION_PLANNING_CONTEXT__?.accountDeclarations.push({
+            binding,
+            ...(authorizationHints && {
+                requiredScopes: authorizationHints.flatMap((hint) => typeof hint === "string" || "type" in hint
+                    ? [hint]
+                    : hint[actionAccountRequirementDefinition].requiredScopes),
+            }),
+            serviceId,
+        });
+        const definition = { binding, serviceId };
+        return {
+            [integrationAccountDefinition]: definition,
+            [serializedIntegrationAccountDefinition]: definition,
+        };
+    };
+}
+/**
+ * Determines whether a runtime value is an integration account reference.
+ *
+ * @param value - Materialized action input value to inspect.
+ */
+export function isIntegrationAccountReference(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        serializedIntegrationAccountDefinition in value);
+}

package/dist/automation/runtime.d.ts

@@ -0,0 +1,73 @@
+import { type Client } from "@automate.ax/client";
+import type { ActionRuntime } from "./actions.js";
+import type { IntegrationScopeRequirement } from "./integrations.js";
+interface RuntimeContext {
+    apiOrigin: string;
+    phase: "execute" | "orchestrate";
+    token: string;
+}
+export type RuntimeBatchContext = Awaited<ReturnType<Client["runtime"]["nextBatch"]>>["context"];
+interface OrchestrationRuntimeState {
+    actionInvocations: {
+        actionDependencyIds: string[];
+        description: string | null;
+        eventDependencyIds: string[];
+        name: string;
+        slot: number;
+    }[];
+    context: RuntimeBatchContext;
+    nextHookSlot: number;
+    phase: "orchestrate";
+}
+interface ExecutionRuntimeState {
+    completeInvocation: Client["runtime"]["completeInvocation"];
+    effects: Promise<void>[];
+    executed: boolean;
+    invocation: Awaited<ReturnType<Client["runtime"]["loadInvocation"]>>;
+    nextHookSlot: number;
+    phase: "execute";
+    resolveAccountInput: Client["runtime"]["resolveAccountInput"];
+    runtime: ActionRuntime;
+}
+export type RuntimeValueContext = ExecutionRuntimeState["invocation"]["context"];
+declare global {
+    var __AUTOMATION_PLANNING_CONTEXT__: {
+        accountDeclarations: {
+            binding: string;
+            requiredScopes?: IntegrationScopeRequirement[];
+            serviceId: string;
+        }[];
+        accountUses: ({
+            binding: string;
+            dynamic: false;
+            requiredScopes: IntegrationScopeRequirement[];
+            serviceId: string;
+        } | {
+            dynamic: true;
+            requiredScopes: IntegrationScopeRequirement[];
+            serviceId: string;
+        })[];
+        nextHookSlot: number;
+        subscriptions: {
+            config: unknown;
+            eventType: string;
+            hookSlot: number;
+        }[];
+    } | undefined;
+    var __AUTOMATION_RUNTIME_CONTEXT__: RuntimeContext | undefined;
+    var __AUTOMATION_RUNTIME_STATE__: ExecutionRuntimeState | OrchestrationRuntimeState | undefined;
+}
+/**
+ * Runs an automation body in local, orchestration, or execution mode.
+ *
+ * @param fn - Automation body whose hook calls should be evaluated.
+ * @throws When execution has no action matching the requested hook slot.
+ */
+export declare function runAutomationFunction(fn: () => void): Promise<void>;
+/**
+ * Reserves the next deterministic hook slot in the active planning or runtime
+ * context.
+ */
+export declare function consumeHookSlot(): number;
+export {};
+//# sourceMappingURL=runtime.d.ts.map

package/dist/automation/runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../../src/automation/runtime.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,KAAK,MAAM,EAAE,MAAM,qBAAqB,CAAA;AAE/D,OAAO,KAAK,EAAE,aAAa,EAAE,qBAAiB;AAC9C,OAAO,KAAK,EAAE,2BAA2B,EAAE,0BAAsB;AAEjE,UAAU,cAAc;IACtB,SAAS,EAAE,MAAM,CAAA;IACjB,KAAK,EAAE,SAAS,GAAG,aAAa,CAAA;IAChC,KAAK,EAAE,MAAM,CAAA;CACd;AAED,MAAM,MAAM,mBAAmB,GAAG,OAAO,CACvC,UAAU,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,WAAW,CAAC,CAAC,CAC3C,CAAC,SAAS,CAAC,CAAA;AAEZ,UAAU,yBAAyB;IACjC,iBAAiB,EAAE;QACjB,mBAAmB,EAAE,MAAM,EAAE,CAAA;QAC7B,WAAW,EAAE,MAAM,GAAG,IAAI,CAAA;QAC1B,kBAAkB,EAAE,MAAM,EAAE,CAAA;QAC5B,IAAI,EAAE,MAAM,CAAA;QACZ,IAAI,EAAE,MAAM,CAAA;KACb,EAAE,CAAA;IACH,OAAO,EAAE,mBAAmB,CAAA;IAC5B,YAAY,EAAE,MAAM,CAAA;IACpB,KAAK,EAAE,aAAa,CAAA;CACrB;AAED,UAAU,qBAAqB;IAC7B,kBAAkB,EAAE,MAAM,CAAC,SAAS,CAAC,CAAC,oBAAoB,CAAC,CAAA;IAC3D,OAAO,EAAE,OAAO,CAAC,IAAI,CAAC,EAAE,CAAA;IACxB,QAAQ,EAAE,OAAO,CAAA;IACjB,UAAU,EAAE,OAAO,CAAC,UAAU,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAA;IACpE,YAAY,EAAE,MAAM,CAAA;IACpB,KAAK,EAAE,SAAS,CAAA;IAChB,mBAAmB,EAAE,MAAM,CAAC,SAAS,CAAC,CAAC,qBAAqB,CAAC,CAAA;IAC7D,OAAO,EAAE,aAAa,CAAA;CACvB;AAED,MAAM,MAAM,mBAAmB,GAAG,qBAAqB,CAAC,YAAY,CAAC,CAAC,SAAS,CAAC,CAAA;AAEhF,OAAO,CAAC,MAAM,CAAC;IACb,IAAI,+BAA+B,EAC/B;QACE,mBAAmB,EAAE;YACnB,OAAO,EAAE,MAAM,CAAA;YACf,cAAc,CAAC,EAAE,2BAA2B,EAAE,CAAA;YAC9C,SAAS,EAAE,MAAM,CAAA;SAClB,EAAE,CAAA;QACH,WAAW,EAAE,CACT;YACE,OAAO,EAAE,MAAM,CAAA;YACf,OAAO,EAAE,KAAK,CAAA;YACd,cAAc,EAAE,2BAA2B,EAAE,CAAA;YAC7C,SAAS,EAAE,MAAM,CAAA;SAClB,GACD;YACE,OAAO,EAAE,IAAI,CAAA;YACb,cAAc,EAAE,2BAA2B,EAAE,CAAA;YAC7C,SAAS,EAAE,MAAM,CAAA;SAClB,CACJ,EAAE,CAAA;QACH,YAAY,EAAE,MAAM,CAAA;QACpB,aAAa,EAAE;YACb,MAAM,EAAE,OAAO,CAAA;YACf,SAAS,EAAE,MAAM,CAAA;YACjB,QAAQ,EAAE,MAAM,CAAA;SACjB,EAAE,CAAA;KACJ,GACD,SAAS,CAAA;IACb,IAAI,8BAA8B,EAAE,cAAc,GAAG,SAAS,CAAA;IAC9D,IAAI,4BAA4B,EAC5B,qBAAqB,GACrB,yBAAyB,GACzB,SAAS,CAAA;CACd;AAED;;;;;GAKG;AACH,wBAAsB,qBAAqB,CAAC,EAAE,EAAE,MAAM,IAAI,iBA4DzD;AAED;;;GAGG;AACH,wBAAgB,eAAe,WAY9B"}

package/dist/automation/runtime.js

@@ -0,0 +1,92 @@
+import { createClient } from "@automate.ax/client";
+import { joinURL } from "ufo";
+/**
+ * Runs an automation body in local, orchestration, or execution mode.
+ *
+ * @param fn - Automation body whose hook calls should be evaluated.
+ * @throws When execution has no action matching the requested hook slot.
+ */
+export async function runAutomationFunction(fn) {
+    const runtimeContext = globalThis.__AUTOMATION_RUNTIME_CONTEXT__;
+    if (!runtimeContext) {
+        fn();
+        return;
+    }
+    if (runtimeContext.phase === "orchestrate") {
+        const client = createRuntimeClient(runtimeContext);
+        const state = {
+            actionInvocations: [],
+            context: (await client.runtime.nextBatch()).context,
+            nextHookSlot: 0,
+            phase: "orchestrate",
+        };
+        globalThis.__AUTOMATION_RUNTIME_STATE__ = state;
+        try {
+            fn();
+            await client.runtime.commit({
+                actionInvocations: state.actionInvocations,
+            });
+        }
+        finally {
+            globalThis.__AUTOMATION_RUNTIME_STATE__ = undefined;
+        }
+        return;
+    }
+    const client = createRuntimeClient(runtimeContext);
+    let nextOutputIndex = 0;
+    const state = {
+        completeInvocation: client.runtime.completeInvocation,
+        effects: [],
+        executed: false,
+        invocation: await client.runtime.loadInvocation(),
+        nextHookSlot: 0,
+        phase: "execute",
+        resolveAccountInput: client.runtime.resolveAccountInput,
+        runtime: {
+            sendOutput: async (output) => {
+                await client.runtime.sendOutput({
+                    output,
+                    outputIndex: nextOutputIndex++,
+                });
+            },
+            sendEmail: async (input) => await client.runtime.sendEmail(input),
+        },
+    };
+    globalThis.__AUTOMATION_RUNTIME_STATE__ = state;
+    try {
+        fn();
+        await Promise.all(state.effects);
+        if (!state.executed) {
+            throw new Error(`No action matched slot ${state.invocation.slot}.`);
+        }
+    }
+    finally {
+        globalThis.__AUTOMATION_RUNTIME_STATE__ = undefined;
+    }
+}
+/**
+ * Reserves the next deterministic hook slot in the active planning or runtime
+ * context.
+ */
+export function consumeHookSlot() {
+    const runtimeState = globalThis.__AUTOMATION_RUNTIME_STATE__;
+    if (runtimeState) {
+        return runtimeState.nextHookSlot++;
+    }
+    const planningContext = globalThis.__AUTOMATION_PLANNING_CONTEXT__;
+    if (planningContext) {
+        return planningContext.nextHookSlot++;
+    }
+    return -1;
+}
+/**
+ * Creates an authenticated API client for an automation runtime.
+ *
+ * @param context - Runtime connection details supplied by the sandbox.
+ */
+function createRuntimeClient(context) {
+    return createClient({
+        apiKey: context.token,
+        url: joinURL(context.apiOrigin, "/api/rpc"),
+    });
+}

package/dist/automation/signal.d.ts

@@ -0,0 +1,58 @@
+export declare const actionProvenance: unique symbol;
+export declare const signalTransform: unique symbol;
+export declare const subscriptionProvenance: unique symbol;
+export declare const signalValueType: unique symbol;
+/** Maps an object payload's properties to child signals. */
+type SignalProperties<T> = {
+    readonly [TKey in keyof NonNullable<T> as TKey extends keyof SignalProtocol<T> ? never : TKey extends string | number ? TKey : never]-?: Signal<NonNullable<T>[TKey]>;
+};
+type SignalProtocol<T> = {
+    readonly [actionProvenance]?: {
+        slot: number;
+    };
+    readonly [signalTransform]?: {
+        inputs: ReadonlyArray<Signal>;
+        transform: SignalTransform;
+    };
+    readonly [subscriptionProvenance]?: {
+        slot: number;
+    };
+    readonly [signalValueType]: () => T;
+    transform<TMapped>(transformer: (value: T) => TMapped): Signal<TMapped>;
+};
+export type Signal<T = unknown> = SignalProtocol<T> & SignalProperties<T>;
+export type SignalTransform = {
+    transform(...inputs: unknown[]): unknown;
+}["transform"];
+/**
+ * Determines whether a value implements the internal signal protocol.
+ *
+ * @param value - Value to inspect.
+ */
+export declare function isSignal(value: unknown): value is Signal;
+/**
+ * Creates a signal for an action output at a deterministic hook slot.
+ *
+ * @param slot - Hook slot assigned to the action invocation.
+ */
+export declare function createActionSignal<T>(slot: number): Signal<T>;
+/**
+ * Creates a signal for a subscription event at a deterministic hook slot.
+ *
+ * @param slot - Hook slot assigned to the subscription.
+ */
+export declare function createSubscriptionSignal<T>(slot: number): Signal<T>;
+/**
+ * Creates a derived signal from explicit graph inputs and a pure transformer.
+ *
+ * Dependency collection traverses the inputs without invoking the transformer.
+ * The transformer runs only after the executor materializes every input.
+ *
+ * @param inputs - Signals consumed by the transformer.
+ * @param transformer - Pure function that computes the derived value.
+ */
+export declare function transform<const TValues extends readonly unknown[], TOutput>(inputs: {
+    readonly [TIndex in keyof TValues]: Signal<TValues[TIndex]>;
+}, transformer: (...inputs: TValues) => TOutput): Signal<TOutput>;
+export {};
+//# sourceMappingURL=signal.d.ts.map

package/dist/automation/signal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signal.d.ts","sourceRoot":"","sources":["../../src/automation/signal.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,gBAAgB,EAAE,OAAO,MAErC,CAAA;AACD,eAAO,MAAM,eAAe,EAAE,OAAO,MAEpC,CAAA;AACD,eAAO,MAAM,sBAAsB,EAAE,OAAO,MAE3C,CAAA;AACD,eAAO,MAAM,eAAe,EAAE,OAAO,MAEpC,CAAA;AAED,4DAA4D;AAC5D,KAAK,gBAAgB,CAAC,CAAC,IAAI;IACzB,QAAQ,EAAE,IAAI,IAAI,MAAM,WAAW,CAAC,CAAC,CAAC,IAAI,IAAI,SAAS,MAAM,cAAc,CAAC,CAAC,CAAC,GAC1E,KAAK,GACL,IAAI,SAAS,MAAM,GAAG,MAAM,GAC1B,IAAI,GACJ,KAAK,CAAC,CAAC,GAAG,MAAM,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;CAC7C,CAAA;AAED,KAAK,cAAc,CAAC,CAAC,IAAI;IACvB,QAAQ,CAAC,CAAC,gBAAgB,CAAC,CAAC,EAAE;QAC5B,IAAI,EAAE,MAAM,CAAA;KACb,CAAA;IACD,QAAQ,CAAC,CAAC,eAAe,CAAC,CAAC,EAAE;QAC3B,MAAM,EAAE,aAAa,CAAC,MAAM,CAAC,CAAA;QAC7B,SAAS,EAAE,eAAe,CAAA;KAC3B,CAAA;IACD,QAAQ,CAAC,CAAC,sBAAsB,CAAC,CAAC,EAAE;QAClC,IAAI,EAAE,MAAM,CAAA;KACb,CAAA;IACD,QAAQ,CAAC,CAAC,eAAe,CAAC,EAAE,MAAM,CAAC,CAAA;IACnC,SAAS,CAAC,OAAO,EAAE,WAAW,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,OAAO,GAAG,MAAM,CAAC,OAAO,CAAC,CAAA;CACxE,CAAA;AAED,MAAM,MAAM,MAAM,CAAC,CAAC,GAAG,OAAO,IAAI,cAAc,CAAC,CAAC,CAAC,GAAG,gBAAgB,CAAC,CAAC,CAAC,CAAA;AAEzE,MAAM,MAAM,eAAe,GAAG;IAC5B,SAAS,CAAC,GAAG,MAAM,EAAE,OAAO,EAAE,GAAG,OAAO,CAAA;CACzC,CAAC,WAAW,CAAC,CAAA;AAEd;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAOxD;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC,CAAC,CAAC,CAI7D;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC,CAAC,CAAC,CAInE;AAED;;;;;;;;GAQG;AACH,wBAAgB,SAAS,CAAC,KAAK,CAAC,OAAO,SAAS,SAAS,OAAO,EAAE,EAAE,OAAO,EACzE,MAAM,EAAE;IACN,QAAQ,EAAE,MAAM,IAAI,MAAM,OAAO,GAAG,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;CAC5D,EACD,WAAW,EAAE,CAAC,GAAG,MAAM,EAAE,OAAO,KAAK,OAAO,GAC3C,MAAM,CAAC,OAAO,CAAC,CAAA"}

package/dist/automation/signal.js

@@ -0,0 +1,80 @@
+export const actionProvenance = Symbol("automation.actionProvenance");
+export const signalTransform = Symbol("automation.signalTransform");
+export const subscriptionProvenance = Symbol("automation.subscriptionProvenance");
+export const signalValueType = Symbol("automation.signalValueType");
+/**
+ * Determines whether a value implements the internal signal protocol.
+ *
+ * @param value - Value to inspect.
+ */
+export function isSignal(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        signalValueType in value &&
+        typeof value[signalValueType] === "function");
+}
+/**
+ * Creates a signal for an action output at a deterministic hook slot.
+ *
+ * @param slot - Hook slot assigned to the action invocation.
+ */
+export function createActionSignal(slot) {
+    return Object.assign(createSignalProxy(), {
+        [actionProvenance]: { slot },
+    });
+}
+/**
+ * Creates a signal for a subscription event at a deterministic hook slot.
+ *
+ * @param slot - Hook slot assigned to the subscription.
+ */
+export function createSubscriptionSignal(slot) {
+    return Object.assign(createSignalProxy(), {
+        [subscriptionProvenance]: { slot },
+    });
+}
+export function transform(inputs, transformer) {
+    return createTransformSignal(inputs, transformer);
+}
+/** Creates the proxy that implements behavior shared by every signal. */
+function createSignalProxy() {
+    const target = {
+        [signalValueType]: () => {
+            throw new Error("Signal type markers cannot be called.");
+        },
+        transform(transformer) {
+            return transform([signal], transformer);
+        },
+    };
+    // oxlint-disable-next-line typescript/no-unsafe-type-assertion -- Proxy traps provide the mapped properties.
+    const signal = new Proxy(target, {
+        get(target, property, receiver) {
+            if (Object.hasOwn(target, property)) {
+                return Reflect.get(target, property, receiver);
+            }
+            if (typeof property !== "string")
+                return undefined;
+            return transform([signal], (value) => {
+                if (value == null) {
+                    throw new TypeError(`Cannot read property ${property} from ${String(value)}.`);
+                }
+                return Reflect.get(Object(value), property);
+            });
+        },
+    });
+    return signal;
+}
+/**
+ * Creates a signal carrying a derived-value transform.
+ *
+ * @param inputs - Signals consumed by the transformer.
+ * @param transformer - Pure function that computes the derived value.
+ */
+function createTransformSignal(inputs, transformer) {
+    return Object.assign(createSignalProxy(), {
+        [signalTransform]: {
+            inputs,
+            transform: transformer,
+        },
+    });
+}

package/dist/automation/subscribe.d.ts

@@ -0,0 +1,10 @@
+import type { Encodable } from "@automate.ax/codec";
+import type { Signal } from "./signal.js";
+/**
+ * Registers an event subscription in planning and creates its signal.
+ *
+ * @param eventType - Event type to subscribe to.
+ * @param config - Configuration for the event type.
+ */
+export declare function subscribe<TEvent extends Encodable>(eventType: string, config: unknown): Signal<TEvent>;
+//# sourceMappingURL=subscribe.d.ts.map

package/dist/automation/subscribe.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subscribe.d.ts","sourceRoot":"","sources":["../../src/automation/subscribe.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAA;AAGnD,OAAO,KAAK,EAAE,MAAM,EAAE,oBAAgB;AAEtC;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,MAAM,SAAS,SAAS,EAChD,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,OAAO,GACd,MAAM,CAAC,MAAM,CAAC,CAShB"}

package/dist/automation/subscribe.js

@@ -0,0 +1,16 @@
+import { consumeHookSlot } from "./runtime.js";
+import { createSubscriptionSignal } from "./signal.js";
+/**
+ * Registers an event subscription in planning and creates its signal.
+ *
+ * @param eventType - Event type to subscribe to.
+ * @param config - Configuration for the event type.
+ */
+export function subscribe(eventType, config) {
+    const hookSlot = consumeHookSlot();
+    const planningContext = globalThis.__AUTOMATION_PLANNING_CONTEXT__;
+    if (planningContext) {
+        planningContext.subscriptions.push({ config, eventType, hookSlot });
+    }
+    return createSubscriptionSignal(hookSlot);
+}

package/dist/cli/command-names.d.ts

@@ -0,0 +1,46 @@
+export declare const commandNames: {
+    readonly accept: "accept";
+    readonly debug: "debug";
+    readonly deploy: "deploy";
+    readonly invite: "invite";
+    readonly login: "login";
+    readonly logout: "logout";
+    readonly me: "me";
+    readonly org: {
+        readonly apiKey: {
+            readonly create: "create";
+            readonly delete: "delete";
+            readonly list: "list";
+            readonly rename: "rename";
+            readonly root: "apikey";
+        };
+        readonly billing: "billing";
+        readonly create: "create";
+        readonly delete: "delete";
+        readonly invite: "invite";
+        readonly leave: "leave";
+        readonly list: "list";
+        readonly remove: "remove";
+        readonly rename: "rename";
+        readonly root: "org";
+        readonly show: "show";
+        readonly upgrade: "upgrade";
+    };
+    readonly project: {
+        readonly create: "create";
+        readonly delete: "delete";
+        readonly list: "list";
+        readonly rename: "rename";
+        readonly root: "project";
+        readonly show: "show";
+    };
+    readonly root: "automate";
+    readonly upgrade: "upgrade";
+};
+export declare const commandExamples: {
+    readonly login: "automate login";
+    readonly orgApiKeyCreate: "automate org apikey create";
+    readonly orgCreate: "automate org create";
+    readonly projectCreate: "automate project create";
+};
+//# sourceMappingURL=command-names.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"command-names.d.ts","sourceRoot":"","sources":["../../src/cli/command-names.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsCf,CAAA;AAEV,eAAO,MAAM,eAAe;;;;;CAKlB,CAAA"}

package/dist/cli/command-names.js

@@ -0,0 +1,46 @@
+const commandRoot = "automate";
+export const commandNames = {
+    accept: "accept",
+    debug: "debug",
+    deploy: "deploy",
+    invite: "invite",
+    login: "login",
+    logout: "logout",
+    me: "me",
+    org: {
+        apiKey: {
+            create: "create",
+            delete: "delete",
+            list: "list",
+            rename: "rename",
+            root: "apikey",
+        },
+        billing: "billing",
+        create: "create",
+        delete: "delete",
+        invite: "invite",
+        leave: "leave",
+        list: "list",
+        remove: "remove",
+        rename: "rename",
+        root: "org",
+        show: "show",
+        upgrade: "upgrade",
+    },
+    project: {
+        create: "create",
+        delete: "delete",
+        list: "list",
+        rename: "rename",
+        root: "project",
+        show: "show",
+    },
+    root: commandRoot,
+    upgrade: "upgrade",
+};
+export const commandExamples = {
+    login: `${commandRoot} ${commandNames.login}`,
+    orgApiKeyCreate: `${commandRoot} ${commandNames.org.root} ${commandNames.org.apiKey.root} ${commandNames.org.apiKey.create}`,
+    orgCreate: `${commandRoot} ${commandNames.org.root} ${commandNames.org.create}`,
+    projectCreate: `${commandRoot} ${commandNames.project.root} ${commandNames.project.create}`,
+};

package/dist/cli/commands/accept.d.ts

@@ -0,0 +1,20 @@
+import z from "zod";
+/** Arguments accepted by the invitation acceptance command. */
+declare const acceptOptsSchema: z.ZodObject<{
+    invitationId: z.ZodString;
+}, z.core.$strip>;
+export declare const acceptCommand: import("citty").CommandDef<{
+    readonly invitationId: {
+        readonly type: "positional";
+        readonly description: "Invitation ID from the invite email";
+        readonly required: true;
+    };
+}>;
+/**
+ * Accepts an organization invitation by ID.
+ *
+ * @param opts - Validated command options containing the invitation ID.
+ */
+export declare function acceptInvitation(opts: z.infer<typeof acceptOptsSchema>): Promise<void>;
+export {};
+//# sourceMappingURL=accept.d.ts.map

package/dist/cli/commands/accept.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"accept.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/accept.ts"],"names":[],"mappings":"AAEA,OAAO,CAAC,MAAM,KAAK,CAAA;AAOnB,+DAA+D;AAC/D,QAAA,MAAM,gBAAgB;;iBAEpB,CAAA;AAEF,eAAO,MAAM,aAAa;;;;;;EAaxB,CAAA;AAEF;;;;GAIG;AACH,wBAAsB,gBAAgB,CAAC,IAAI,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,iBAY5E"}

package/dist/cli/commands/accept.js

@@ -0,0 +1,42 @@
+import { log } from "@clack/prompts";
+import { defineCommand } from "citty";
+import z from "zod";
+import { commandNames } from "../command-names.js";
+import { authClient } from "../lib/auth-client.js";
+import { createCommandRun, output, useSession } from "../utils.js";
+import { accent } from "../lib/io.js";
+import { clearSpinner, startSpinner } from "../lib/spinner.js";
+/** Arguments accepted by the invitation acceptance command. */
+const acceptOptsSchema = z.object({
+    invitationId: z.string(),
+});
+export const acceptCommand = defineCommand({
+    meta: {
+        name: commandNames.accept,
+        description: "Accept an organization invitation",
+    },
+    args: {
+        invitationId: {
+            type: "positional",
+            description: "Invitation ID from the invite email",
+            required: true,
+        },
+    },
+    run: createCommandRun(acceptOptsSchema, acceptInvitation),
+});
+/**
+ * Accepts an organization invitation by ID.
+ *
+ * @param opts - Validated command options containing the invitation ID.
+ */
+export async function acceptInvitation(opts) {
+    await useSession();
+    startSpinner("Accepting invitation");
+    const { member } = await authClient.organization.acceptInvitation({
+        invitationId: opts.invitationId,
+    });
+    clearSpinner();
+    output
+        .normal(() => log.success(`Joined organization as ${accent(member.role)}`))
+        .json(member);
+}

package/dist/cli/commands/debug.d.ts

@@ -0,0 +1,4 @@
+export declare const debugCommand: import("citty").CommandDef<import("citty").ArgsDef>;
+/** Logs APP_ORIGIN and the RPC/auth base URLs derived from it. */
+export declare function debug(): Promise<void>;
+//# sourceMappingURL=debug.d.ts.map

package/dist/cli/commands/debug.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"debug.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/debug.ts"],"names":[],"mappings":"AAUA,eAAO,MAAM,YAAY,qDAMvB,CAAA;AAEF,kEAAkE;AAClE,wBAAsB,KAAK,kBA2C1B"}