@dxos/plugin-routine 0.0.0

package/dist/types/src/testing/test-functions.d.ts

@@ -0,0 +1,328 @@
+import { DXN } from '@dxos/echo';
+/**
+ * Operations seeded into the local space in stories.
+ */
+export declare const functions: ({
+    key: DXN.DXN;
+    name: string;
+    version: string;
+    inputSchema: {
+        $id?: string | undefined;
+        $schema?: string | undefined;
+        $ref?: string | undefined;
+        $comment?: string | undefined;
+        entityKind?: import("@dxos/echo/internal").EntityKind | undefined;
+        typename?: string | undefined;
+        version?: string | undefined;
+        relationTarget?: /*elided*/ any | undefined;
+        relationSource?: /*elided*/ any | undefined;
+        title?: string | undefined;
+        description?: string | undefined;
+        readOnly?: boolean | undefined;
+        writeOnly?: boolean | undefined;
+        examples?: any[] | undefined;
+        default?: any;
+        const?: any;
+        enum?: any[] | undefined;
+        type?: "array" | "boolean" | "integer" | "null" | "number" | "object" | "string" | ("array" | "boolean" | "integer" | "null" | "number" | "object" | "string")[] | undefined;
+        multipleOf?: number | undefined;
+        maximum?: number | undefined;
+        exclusiveMaximum?: number | undefined;
+        minimum?: number | undefined;
+        exclusiveMinimum?: number | undefined;
+        maxLength?: number | undefined;
+        pattern?: string | undefined;
+        format?: string | undefined;
+        minLength?: number | undefined;
+        items?: /*elided*/ any[] | /*elided*/ any | undefined;
+        additionalItems?: boolean | /*elided*/ any | undefined;
+        maxItems?: number | undefined;
+        minItems?: number | undefined;
+        uniqueItems?: boolean | undefined;
+        contains?: /*elided*/ any | undefined;
+        maxProperties?: number | undefined;
+        minProperties?: number | undefined;
+        required?: string[] | undefined;
+        propertyOrder?: string[] | undefined;
+        additionalProperties?: boolean | /*elided*/ any | undefined;
+        properties?: {
+            [x: string]: /*elided*/ any;
+        } | undefined;
+        patternProperties?: {
+            [x: string]: any;
+        } | undefined;
+        propertyNames?: /*elided*/ any | undefined;
+        definitions?: {
+            [x: string]: any;
+        } | undefined;
+        dependencies?: {
+            [x: string]: string | string[] | /*elided*/ any;
+        } | undefined;
+        contentMediaType?: string | undefined;
+        contentEncoding?: string | undefined;
+        if?: /*elided*/ any | undefined;
+        then?: /*elided*/ any | undefined;
+        else?: /*elided*/ any | undefined;
+        allOf?: /*elided*/ any[] | undefined;
+        anyOf?: /*elided*/ any[] | undefined;
+        oneOf?: /*elided*/ any[] | undefined;
+        not?: /*elided*/ any | undefined;
+        $defs?: {
+            [x: string]: any;
+        } | undefined;
+        currency?: string | undefined;
+        reference?: {
+            schema: /*elided*/ any;
+            schemaVersion?: string | undefined;
+            schemaObject?: string | undefined;
+        } | undefined;
+        annotations?: {
+            labelProp?: import("@dxos/effect").JsonPath[] | import("@dxos/effect").JsonPath | undefined;
+            generator?: string | [string, number] | undefined;
+            meta?: {
+                [x: string]: any;
+            } | undefined;
+            type?: {
+                typename: string;
+                version: string;
+                schemaId?: string | undefined;
+            } | undefined;
+            annotations?: {
+                [x: string]: any;
+            } | undefined;
+        } | undefined;
+        echo?: {
+            labelProp?: import("@dxos/effect").JsonPath[] | import("@dxos/effect").JsonPath | undefined;
+            generator?: string | [string, number] | undefined;
+            meta?: {
+                [x: string]: any;
+            } | undefined;
+            type?: {
+                typename: string;
+                version: string;
+                schemaId?: string | undefined;
+            } | undefined;
+            annotations?: {
+                [x: string]: any;
+            } | undefined;
+        } | undefined;
+    };
+    binding?: undefined;
+} | {
+    key: DXN.DXN;
+    name: string;
+    version: string;
+    binding: string;
+    inputSchema: {
+        $id?: string | undefined;
+        $schema?: string | undefined;
+        $ref?: string | undefined;
+        $comment?: string | undefined;
+        entityKind?: import("@dxos/echo/internal").EntityKind | undefined;
+        typename?: string | undefined;
+        version?: string | undefined;
+        relationTarget?: any | undefined;
+        relationSource?: any | undefined;
+        title?: string | undefined;
+        description?: string | undefined;
+        readOnly?: boolean | undefined;
+        writeOnly?: boolean | undefined;
+        examples?: any[] | undefined;
+        default?: any;
+        const?: any;
+        enum?: any[] | undefined;
+        type?: "array" | "boolean" | "integer" | "null" | "number" | "object" | "string" | ("array" | "boolean" | "integer" | "null" | "number" | "object" | "string")[] | undefined;
+        multipleOf?: number | undefined;
+        maximum?: number | undefined;
+        exclusiveMaximum?: number | undefined;
+        minimum?: number | undefined;
+        exclusiveMinimum?: number | undefined;
+        maxLength?: number | undefined;
+        pattern?: string | undefined;
+        format?: string | undefined;
+        minLength?: number | undefined;
+        items?: any[] | any | undefined;
+        additionalItems?: boolean | any | undefined;
+        maxItems?: number | undefined;
+        minItems?: number | undefined;
+        uniqueItems?: boolean | undefined;
+        contains?: any | undefined;
+        maxProperties?: number | undefined;
+        minProperties?: number | undefined;
+        required?: string[] | undefined;
+        propertyOrder?: string[] | undefined;
+        additionalProperties?: boolean | any | undefined;
+        properties?: {
+            [x: string]: any;
+        } | undefined;
+        patternProperties?: {
+            [x: string]: any;
+        } | undefined;
+        propertyNames?: any | undefined;
+        definitions?: {
+            [x: string]: any;
+        } | undefined;
+        dependencies?: {
+            [x: string]: string | string[] | any;
+        } | undefined;
+        contentMediaType?: string | undefined;
+        contentEncoding?: string | undefined;
+        if?: any | undefined;
+        then?: any | undefined;
+        else?: any | undefined;
+        allOf?: any[] | undefined;
+        anyOf?: any[] | undefined;
+        oneOf?: any[] | undefined;
+        not?: any | undefined;
+        $defs?: {
+            [x: string]: any;
+        } | undefined;
+        currency?: string | undefined;
+        reference?: {
+            schema: any;
+            schemaVersion?: string | undefined;
+            schemaObject?: string | undefined;
+        } | undefined;
+        annotations?: {
+            labelProp?: import("@dxos/effect").JsonPath[] | import("@dxos/effect").JsonPath | undefined;
+            generator?: string | [string, number] | undefined;
+            meta?: {
+                [x: string]: any;
+            } | undefined;
+            type?: {
+                typename: string;
+                version: string;
+                schemaId?: string | undefined;
+            } | undefined;
+            annotations?: {
+                [x: string]: any;
+            } | undefined;
+        } | undefined;
+        echo?: {
+            labelProp?: import("@dxos/effect").JsonPath[] | import("@dxos/effect").JsonPath | undefined;
+            generator?: string | [string, number] | undefined;
+            meta?: {
+                [x: string]: any;
+            } | undefined;
+            type?: {
+                typename: string;
+                version: string;
+                schemaId?: string | undefined;
+            } | undefined;
+            annotations?: {
+                [x: string]: any;
+            } | undefined;
+        } | undefined;
+    };
+})[];
+/**
+ * Operations seeded into the registry (not the local space) in stories.
+ * Simulates built-in or plugin-provided operations available globally.
+ */
+export declare const registryFunctions: {
+    key: string;
+    name: string;
+    version: string;
+    inputSchema: {
+        $id?: string | undefined;
+        $schema?: string | undefined;
+        $ref?: string | undefined;
+        $comment?: string | undefined;
+        entityKind?: import("@dxos/echo/internal").EntityKind | undefined;
+        typename?: string | undefined;
+        version?: string | undefined;
+        relationTarget?: /*elided*/ any | undefined;
+        relationSource?: /*elided*/ any | undefined;
+        title?: string | undefined;
+        description?: string | undefined;
+        readOnly?: boolean | undefined;
+        writeOnly?: boolean | undefined;
+        examples?: any[] | undefined;
+        default?: any;
+        const?: any;
+        enum?: any[] | undefined;
+        type?: "array" | "boolean" | "integer" | "null" | "number" | "object" | "string" | ("array" | "boolean" | "integer" | "null" | "number" | "object" | "string")[] | undefined;
+        multipleOf?: number | undefined;
+        maximum?: number | undefined;
+        exclusiveMaximum?: number | undefined;
+        minimum?: number | undefined;
+        exclusiveMinimum?: number | undefined;
+        maxLength?: number | undefined;
+        pattern?: string | undefined;
+        format?: string | undefined;
+        minLength?: number | undefined;
+        items?: /*elided*/ any[] | /*elided*/ any | undefined;
+        additionalItems?: boolean | /*elided*/ any | undefined;
+        maxItems?: number | undefined;
+        minItems?: number | undefined;
+        uniqueItems?: boolean | undefined;
+        contains?: /*elided*/ any | undefined;
+        maxProperties?: number | undefined;
+        minProperties?: number | undefined;
+        required?: string[] | undefined;
+        propertyOrder?: string[] | undefined;
+        additionalProperties?: boolean | /*elided*/ any | undefined;
+        properties?: {
+            [x: string]: /*elided*/ any;
+        } | undefined;
+        patternProperties?: {
+            [x: string]: any;
+        } | undefined;
+        propertyNames?: /*elided*/ any | undefined;
+        definitions?: {
+            [x: string]: any;
+        } | undefined;
+        dependencies?: {
+            [x: string]: string | string[] | /*elided*/ any;
+        } | undefined;
+        contentMediaType?: string | undefined;
+        contentEncoding?: string | undefined;
+        if?: /*elided*/ any | undefined;
+        then?: /*elided*/ any | undefined;
+        else?: /*elided*/ any | undefined;
+        allOf?: /*elided*/ any[] | undefined;
+        anyOf?: /*elided*/ any[] | undefined;
+        oneOf?: /*elided*/ any[] | undefined;
+        not?: /*elided*/ any | undefined;
+        $defs?: {
+            [x: string]: any;
+        } | undefined;
+        currency?: string | undefined;
+        reference?: {
+            schema: /*elided*/ any;
+            schemaVersion?: string | undefined;
+            schemaObject?: string | undefined;
+        } | undefined;
+        annotations?: {
+            labelProp?: import("@dxos/effect").JsonPath[] | import("@dxos/effect").JsonPath | undefined;
+            generator?: string | [string, number] | undefined;
+            meta?: {
+                [x: string]: any;
+            } | undefined;
+            type?: {
+                typename: string;
+                version: string;
+                schemaId?: string | undefined;
+            } | undefined;
+            annotations?: {
+                [x: string]: any;
+            } | undefined;
+        } | undefined;
+        echo?: {
+            labelProp?: import("@dxos/effect").JsonPath[] | import("@dxos/effect").JsonPath | undefined;
+            generator?: string | [string, number] | undefined;
+            meta?: {
+                [x: string]: any;
+            } | undefined;
+            type?: {
+                typename: string;
+                version: string;
+                schemaId?: string | undefined;
+            } | undefined;
+            annotations?: {
+                [x: string]: any;
+            } | undefined;
+        } | undefined;
+    };
+}[];
+//# sourceMappingURL=test-functions.d.ts.map

package/dist/types/src/testing/test-functions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-functions.d.ts","sourceRoot":"","sources":["../../../../src/testing/test-functions.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,GAAG,EAAmB,MAAM,YAAY,CAAC;AAElD;;GAEG;AACH,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAmCrB,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsB7B,CAAC"}

package/dist/types/src/testing.d.ts

@@ -0,0 +1,2 @@
+export * from './RoutinePlugin';
+//# sourceMappingURL=testing.d.ts.map

package/dist/types/src/testing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"testing.d.ts","sourceRoot":"","sources":["../../../src/testing.ts"],"names":[],"mappings":"AAMA,cAAc,iBAAiB,CAAC"}

package/dist/types/src/translations.d.ts

@@ -0,0 +1,3 @@
+import { type Resource } from '@dxos/react-ui';
+export declare const translations: Resource[];
+//# sourceMappingURL=translations.d.ts.map

package/dist/types/src/translations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"translations.d.ts","sourceRoot":"","sources":["../../../src/translations.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAO/C,eAAO,MAAM,YAAY,EAAE,QAAQ,EAgHJ,CAAC"}

package/dist/types/src/types/Routine.d.ts

@@ -0,0 +1,55 @@
+import * as Schema from 'effect/Schema';
+import { Instructions, Runnable, Trigger } from '@dxos/compute';
+import { Operation } from '@dxos/compute';
+import { Obj, Ref, Type } from '@dxos/echo';
+declare const Kinds: readonly ['runnable', 'instructions'];
+export declare const Kind: Schema.Literal<["runnable", "instructions"]>;
+export type Kind = (typeof Kinds)[number];
+declare const Routine_base: Type.ObjClass<Routine, {
+    readonly name?: string | undefined;
+    readonly description?: string | undefined;
+    readonly spec?: {
+        readonly kind: "runnable";
+        readonly runnable: import("@dxos/echo/internal").Ref<Operation.PersistentOperation & import("@dxos/echo/Entity").OfKind<import("@dxos/echo/internal").EntityKind.Object> & Obj.Unknown>;
+    } | {
+        readonly kind: "instructions";
+        readonly instructions: import("@dxos/echo/internal").Ref<Instructions.Instructions & import("@dxos/echo/Entity").OfKind<import("@dxos/echo/internal").EntityKind.Object> & Obj.Unknown>;
+    } | undefined;
+    readonly triggers: readonly import("@dxos/echo/internal").Ref<Trigger.Trigger & import("@dxos/echo/Entity").OfKind<import("@dxos/echo/internal").EntityKind.Object> & Obj.Unknown>[];
+}, {}>;
+/**
+ * User-facing routine: a thin aggregate of an action (`runnable`) and the triggers that fire it.
+ * App-level only — EDGE stays unaware of it (triggers point directly at the runnable).
+ */
+export declare class Routine extends Routine_base {
+}
+/** Returns true when value is a Routine object. */
+export declare const instanceOf: (value: unknown) => value is Routine;
+/**
+ * The owned Instructions ref of an instructions-action routine, or undefined for an operation action.
+ * Classification is explicit in `spec.kind`, so this needs no `.target` dereference; callers resolve the ref
+ * reactively (`useObject`) or asynchronously (`Database.load`) as appropriate.
+ */
+export declare const instructionsRef: (routine: Pick<Routine, 'spec'>) => Ref.Ref<Instructions.Instructions> | undefined;
+/** The Operation (runnable) ref of an operation-action routine, or undefined for an instructions action. */
+export declare const runnableRef: (routine: Pick<Routine, 'spec'>) => Ref.Ref<Runnable.Runnable> | undefined;
+/**
+ * Wire the routine's owned triggers to dispatch its current action (`spec`): an instructions action sets each
+ * trigger's `runnable` to RunInstructions with the owned instructions bound into `input`; an operation action
+ * binds the operation directly and drops any stale instructions binding. Call after the action (`spec`) changes
+ * so a trigger never keeps a binding for the previous action.
+ */
+export declare const wireTriggers: (routine: Routine) => void;
+/**
+ * Creates a fully-wired in-memory routine graph. `instructions` and `trigger` are optional extras beyond the
+ * schema fields: when provided they are parented under the routine and wired together (runnable, trigger
+ * runnable, the trigger's instructions input binding, and the `triggers` ref) so that a single `Database.add`
+ * cascades the whole graph. `triggers` defaults to `[]` so callers that supply a `trigger` need not provide it.
+ */
+export declare const make: ({ instructions, trigger, triggers, ...props }: Omit<Obj.MakeProps<typeof Routine>, 'triggers'> & {
+    triggers?: ReadonlyArray<Ref.Ref<Trigger.Trigger>>;
+    instructions?: Instructions.Instructions;
+    trigger?: Trigger.Trigger;
+}) => Routine;
+export {};
+//# sourceMappingURL=Routine.d.ts.map

package/dist/types/src/types/Routine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Routine.d.ts","sourceRoot":"","sources":["../../../../src/types/Routine.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAExC,OAAO,EAAE,YAAY,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAIhE,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC1C,OAAO,EAAmB,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAK7D,QAAA,MAAM,KAAK,YAAI,UAAU,EAAE,cAAc,CAAU,CAAC;AACpD,eAAO,MAAM,IAAI,8CAA2B,CAAC;AAC7C,MAAM,MAAM,IAAI,GAAG,CAAC,OAAO,KAAK,CAAC,CAAC,MAAM,CAAC,CAAC;;;;;;;;;;;;;AAc1C;;;GAGG;AACH,qBAAa,OAAQ,SAAQ,YAyB5B;CAAG;AAEJ,mDAAmD;AACnD,eAAO,MAAM,UAAU,UAAW,OAAO,KAAG,KAAK,IAAI,OAAyC,CAAC;AAE/F;;;;GAIG;AACH,eAAO,MAAM,eAAe,YAAa,IAAI,CAAC,OAAO,EAAE,MAAM,CAAC,KAAG,GAAG,CAAC,GAAG,CAAC,YAAY,CAAC,YAAY,CAAC,GAAG,SACvB,CAAC;AAEhF,4GAA4G;AAC5G,eAAO,MAAM,WAAW,YAAa,IAAI,CAAC,OAAO,EAAE,MAAM,CAAC,KAAG,GAAG,CAAC,GAAG,CAAC,QAAQ,CAAC,QAAQ,CAAC,GAAG,SACnB,CAAC;AAWxE;;;;;GAKG;AACH,eAAO,MAAM,YAAY,YAAa,OAAO,KAAG,IAc/C,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,IAAI,kDAKd,IAAI,CAAC,GAAG,CAAC,SAAS,CAAC,OAAO,OAAO,CAAC,EAAE,UAAU,CAAC,GAAG;IACnD,QAAQ,CAAC,EAAE,aAAa,CAAC,GAAG,CAAC,GAAG,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC;IACnD,YAAY,CAAC,EAAE,YAAY,CAAC,YAAY,CAAC;IACzC,OAAO,CAAC,EAAE,OAAO,CAAC,OAAO,CAAC;CAC3B,KAAG,OAiBH,CAAC"}

package/dist/types/src/types/Routine.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=Routine.test.d.ts.map

package/dist/types/src/types/Routine.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Routine.test.d.ts","sourceRoot":"","sources":["../../../../src/types/Routine.test.ts"],"names":[],"mappings":""}

package/dist/types/src/types/RoutineCapabilities.d.ts

@@ -0,0 +1,44 @@
+import type * as Effect from 'effect/Effect';
+import { Capability } from '@dxos/app-framework';
+import type { Database, Obj } from '@dxos/echo';
+import type { DelegationStrategy } from '@dxos/functions-runtime';
+import * as Routine from './Routine';
+/**
+ * Optional supervisor strategy for the agent chat service. When contributed (by a plugin that knows
+ * the agent/plan model, e.g. plugin-assistant), the conversational agent delegates outstanding work
+ * to sub-agents and folds their results back into the conversation. Consumed by the AgentService
+ * LayerSpec; absent by default (a plain conversational agent).
+ */
+export declare const AgentDelegationStrategy: Capability.InterfaceDef<DelegationStrategy>;
+/**
+ * An automation template contributed by a plugin. The create dialog and the per-object "Automations"
+ * companion list contributed templates (`Capability.getAll(RoutineCapabilities.Template)`) and run the
+ * chosen template's `scaffold` to build the automation.
+ */
+export type Template = {
+    /** Stable id (e.g. 'org.dxos.routine.blank'). */
+    id: string;
+    /** Human-readable label shown in the picker. */
+    label: string;
+    /** Optional Phosphor icon name. */
+    icon?: string;
+    /**
+     * Whether this template applies to the given companion subject. The subject is the object whose
+     * "Automations" companion is open, or undefined in the global create dialog. Templates that need a
+     * specific subject (e.g. a feed-bearing Mailbox) gate themselves here. Defaults to always-applies.
+     */
+    appliesTo?: (subject?: Obj.Unknown) => boolean;
+    /**
+     * Build the routine as a fully-wired in-memory {@link Routine.Routine} graph — the routine plus its owned
+     * trigger and instructions, assembled by `Routine.make`. The create flow persists it with a single
+     * `Database.add` (which cascades the owned children); scaffold must NOT call `Database.add` itself.
+     * `Database.Service` may still be used for read-only lookups (e.g. loading a feed ref). `subject` is set
+     * when scaffolding from an object's companion.
+     */
+    scaffold: (ctx: {
+        name?: string;
+        subject?: Obj.Unknown;
+    }) => Effect.Effect<Routine.Routine, Error, Database.Service>;
+};
+export declare const Template: Capability.InterfaceDef<Template>;
+//# sourceMappingURL=RoutineCapabilities.d.ts.map

package/dist/types/src/types/RoutineCapabilities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RoutineCapabilities.d.ts","sourceRoot":"","sources":["../../../../src/types/RoutineCapabilities.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,KAAK,MAAM,MAAM,eAAe,CAAC;AAE7C,OAAO,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AACjD,OAAO,KAAK,EAAE,QAAQ,EAAE,GAAG,EAAE,MAAM,YAAY,CAAC;AAChD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAElE,OAAO,KAAK,OAAO,MAAM,WAAW,CAAC;AAErC;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB,6CAEnC,CAAC;AAEF;;;;GAIG;AACH,MAAM,MAAM,QAAQ,GAAG;IACrB,iDAAiD;IACjD,EAAE,EAAE,MAAM,CAAC;IACX,gDAAgD;IAChD,KAAK,EAAE,MAAM,CAAC;IACd,mCAAmC;IACnC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd;;;;OAIG;IACH,SAAS,CAAC,EAAE,CAAC,OAAO,CAAC,EAAE,GAAG,CAAC,OAAO,KAAK,OAAO,CAAC;IAC/C;;;;;;OAMG;IACH,QAAQ,EAAE,CAAC,GAAG,EAAE;QAAE,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,GAAG,CAAC,OAAO,CAAA;KAAE,KAAK,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,OAAO,EAAE,KAAK,EAAE,QAAQ,CAAC,OAAO,CAAC,CAAC;CACtH,CAAC;AAEF,eAAO,MAAM,QAAQ,mCAA2E,CAAC"}

package/dist/types/src/types/RoutineOperation.d.ts

@@ -0,0 +1,45 @@
+import { Capability } from '@dxos/app-framework';
+import { Chat } from '@dxos/assistant-toolkit';
+import { Instructions, Operation } from '@dxos/compute';
+import { Database, Obj } from '@dxos/echo';
+import { EID as _EchoURIReference } from '@dxos/keys';
+import * as Routine from './Routine';
+export { _EchoURIReference };
+export declare const CreateTriggerFromTemplate: Operation.Definition<{
+    readonly db: Database.Database;
+    readonly template: {
+        readonly type: "timer";
+        readonly cron: string;
+    } | {
+        readonly type: "feed";
+        readonly feed: any;
+    };
+    readonly enabled?: boolean | undefined;
+    readonly scriptName?: string | undefined;
+    readonly input?: {
+        readonly [x: string]: any;
+    } | undefined;
+}, void, Capability.Service>;
+export declare const CreateRoutine: Operation.Definition<{
+    readonly db: Database.Database;
+    readonly templateId: string;
+    readonly name?: string | undefined;
+    readonly subject?: Obj.Unknown | undefined;
+}, {
+    readonly id: string;
+    readonly subject: readonly string[];
+    readonly object: Obj.Unknown;
+}, Capability.Service>;
+export declare const RunPromptInNewChat: Operation.Definition<{
+    readonly db: Database.Database;
+    readonly objects?: readonly Obj.Unknown[] | undefined;
+    readonly skills?: readonly string[] | undefined;
+    readonly instructions: string | import("@dxos/echo/internal").Ref<Instructions.Instructions & import("@dxos/echo/Entity").OfKind<import("@dxos/echo/internal").EntityKind.Object> & Obj.Unknown>;
+    readonly background?: boolean | undefined;
+}, {
+    readonly object: Chat.Chat & import("@dxos/echo/Entity").OfKind<import("@dxos/echo/internal").EntityKind.Object>;
+}, Capability.Service>;
+export declare const RunRoutine: Operation.Definition<{
+    readonly routine: import("@dxos/echo/internal").Ref<Routine.Routine & import("@dxos/echo/Entity").OfKind<import("@dxos/echo/internal").EntityKind.Object> & Obj.Unknown>;
+}, void, Capability.Service>;
+//# sourceMappingURL=RoutineOperation.d.ts.map

package/dist/types/src/types/RoutineOperation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RoutineOperation.d.ts","sourceRoot":"","sources":["../../../../src/types/RoutineOperation.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AACjD,OAAO,EAAE,IAAI,EAAE,MAAM,yBAAyB,CAAC;AAC/C,OAAO,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AACxD,OAAO,EAAE,QAAQ,EAAO,GAAG,EAAa,MAAM,YAAY,CAAC;AAI3D,OAAO,EAAE,GAAG,IAAI,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAItD,OAAO,KAAK,OAAO,MAAM,WAAW,CAAC;AAErC,OAAO,EAAE,iBAAiB,EAAE,CAAC;AAI7B,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;4BAepC,CAAC;AAIH,eAAO,MAAM,aAAa;;;;;;;;;sBAkBxB,CAAC;AAEH,eAAO,MAAM,kBAAkB;;;;;;;;sBAuB7B,CAAC;AAKH,eAAO,MAAM,UAAU;;4BAWrB,CAAC"}

package/dist/types/src/types/index.d.ts

@@ -0,0 +1,5 @@
+export * from './schema';
+export * as Routine from './Routine';
+export * as RoutineCapabilities from './RoutineCapabilities';
+export * as RoutineOperation from './RoutineOperation';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/src/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/types/index.ts"],"names":[],"mappings":"AAIA,cAAc,UAAU,CAAC;AAEzB,OAAO,KAAK,OAAO,MAAM,WAAW,CAAC;AACrC,OAAO,KAAK,mBAAmB,MAAM,uBAAuB,CAAC;AAC7D,OAAO,KAAK,gBAAgB,MAAM,oBAAoB,CAAC"}

package/dist/types/src/types/schema.d.ts

@@ -0,0 +1,33 @@
+import * as Schema from 'effect/Schema';
+import { Database } from '@dxos/echo';
+export declare const TriggerTemplate: Schema.Union<[Schema.Struct<{
+    type: Schema.Literal<["timer"]>;
+    cron: typeof Schema.String;
+}>, Schema.Struct<{
+    type: Schema.Literal<["feed"]>;
+    feed: typeof Schema.Any;
+}>]>;
+export declare namespace AutomationAction {
+    const CreateTriggerFromTemplate_base: Schema.TaggedClass<CreateTriggerFromTemplate, `${string}.action.create-trigger-from-template`, {
+        readonly _tag: Schema.tag<`${string}.action.create-trigger-from-template`>;
+    } & {
+        input: Schema.Struct<{
+            db: Schema.Schema<Database.Database, Database.Database, never>;
+            template: Schema.Union<[Schema.Struct<{
+                type: Schema.Literal<["timer"]>;
+                cron: typeof Schema.String;
+            }>, Schema.Struct<{
+                type: Schema.Literal<["feed"]>;
+                feed: typeof Schema.Any;
+            }>]>;
+            enabled: Schema.optional<typeof Schema.Boolean>;
+            scriptName: Schema.optional<typeof Schema.String>;
+            input: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.Any>>;
+        }>;
+        output: typeof Schema.Void;
+    }>;
+    export class CreateTriggerFromTemplate extends CreateTriggerFromTemplate_base {
+    }
+    export {};
+}
+//# sourceMappingURL=schema.d.ts.map

package/dist/types/src/types/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../../src/types/schema.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAExC,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAItC,eAAO,MAAM,eAAe;;;;;;IAG3B,CAAC;AAEF,yBAAiB,gBAAgB,CAAC,CAAC;;;;;;;;;;;;;;;;;;;IACjC,MAAM,OAAO,yBAA0B,SAAQ,8BAa9C;KAAG;;CACL"}

package/dist/types/src/util/index.d.ts

@@ -0,0 +1,3 @@
+export * from './routines-for-object';
+export * from './run-instructions';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/src/util/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/util/index.ts"],"names":[],"mappings":"AAIA,cAAc,uBAAuB,CAAC;AACtC,cAAc,oBAAoB,CAAC"}

package/dist/types/src/util/routines-for-object.d.ts

@@ -0,0 +1,22 @@
+import { Obj, Query } from '@dxos/echo';
+import { Routine } from '#types';
+/**
+ * Reactive query for all routines connected to an object O, via two structural paths:
+ *
+ * 1. **Trigger path** (two hops): O is referenced by a Trigger (via `input` or `spec.feed`), and that
+ *    Trigger is referenced by a Routine's `triggers` array.
+ * 2. **Instructions path** (two hops): O is listed in an Instructions' `objects` context array, and those
+ *    Instructions are the Routine's action (`spec.instructions`). Both hops traverse `Ref` fields, so they are
+ *    fully queryable — no JavaScript parent-symbol traversal needed.
+ *
+ * ECHO's reverse-ref index is structural — it tracks every `Ref` regardless of schema path, including
+ * nested untyped records and union fields — so all variants are covered.
+ */
+export declare const connectedRoutinesQuery: (object: Obj.Unknown) => Query.Query<Routine.Routine>;
+/**
+ * Pure predicate equivalent of {@link connectedRoutinesQuery}, over a pre-queried list of routines.
+ * Kept for unit tests (asserting the query and predicate agree) and the deferred quick-association check.
+ */
+export declare const routinesForObject: (object: Obj.Unknown, routines: Routine.Routine[]) => Routine.Routine[];
+export declare const routineReferencesObject: (routine: Routine.Routine, object: Obj.Unknown) => boolean;
+//# sourceMappingURL=routines-for-object.d.ts.map

package/dist/types/src/util/routines-for-object.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"routines-for-object.d.ts","sourceRoot":"","sources":["../../../../src/util/routines-for-object.ts"],"names":[],"mappings":"AAKA,OAAO,EAAU,GAAG,EAAE,KAAK,EAAO,MAAM,YAAY,CAAC;AAErD,OAAO,EAAE,OAAO,EAAE,MAAM,QAAQ,CAAC;AAEjC;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,sBAAsB,WAAY,GAAG,CAAC,OAAO,KAAG,KAAK,CAAC,KAAK,CAAC,OAAO,CAAC,OAAO,CAgBvF,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,iBAAiB,WAAY,GAAG,CAAC,OAAO,YAAY,OAAO,CAAC,OAAO,EAAE,KAAG,OAAO,CAAC,OAAO,EAC5B,CAAC;AAEzE,eAAO,MAAM,uBAAuB,YAAa,OAAO,CAAC,OAAO,UAAU,GAAG,CAAC,OAAO,KAAG,OACH,CAAC"}

package/dist/types/src/util/routines-for-object.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=routines-for-object.test.d.ts.map

package/dist/types/src/util/routines-for-object.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"routines-for-object.test.d.ts","sourceRoot":"","sources":["../../../../src/util/routines-for-object.test.ts"],"names":[],"mappings":""}

package/dist/types/src/util/run-instructions.d.ts

@@ -0,0 +1,5 @@
+/** A ref to the shared RunInstructions operation in the registry (resolved via the registry, not the database). */
+export declare const runInstructionsRef: () => import("@dxos/echo/internal").Ref<any>;
+/** Whether a trigger's `function` ref targets the registry RunInstructions operation (i.e. an instructions action). */
+export declare const isRunInstructions: (fn: unknown) => boolean;
+//# sourceMappingURL=run-instructions.d.ts.map

package/dist/types/src/util/run-instructions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-instructions.d.ts","sourceRoot":"","sources":["../../../../src/util/run-instructions.ts"],"names":[],"mappings":"AAOA,mHAAmH;AACnH,eAAO,MAAM,kBAAkB,8CAA8C,CAAC;AAE9E,uHAAuH;AACvH,eAAO,MAAM,iBAAiB,OAAQ,OAAO,KAAG,OAA+D,CAAC"}

package/dist/types/src/util/run-instructions.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=run-instructions.test.d.ts.map

package/dist/types/src/util/run-instructions.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-instructions.test.d.ts","sourceRoot":"","sources":["../../../../src/util/run-instructions.test.ts"],"names":[],"mappings":""}