@dxos/compute 0.8.3 → 0.8.4-main.03d5cd7b56

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

@@ -0,0 +1,150 @@
+import * as Schema from 'effect/Schema';
+import { Feed, Obj, QueryAST, Type, type Query } from '@dxos/echo';
+/**
+ * Type discriminator for TriggerType.
+ * Every spec has a type field of type TriggerKind that we can use to understand which type we're working with.
+ * https://www.typescriptlang.org/docs/handbook/2/narrowing.html#discriminated-unions
+ */
+export declare const Kinds: readonly ['email', 'queue', 'subscription', 'timer', 'webhook'];
+export type Kind = (typeof Kinds)[number];
+export declare const EmailSpec: Schema.Struct<{
+    kind: Schema.Literal<["email"]>;
+}>;
+export type EmailSpec = Schema.Schema.Type<typeof EmailSpec>;
+/**
+ * Construct an Email trigger spec.
+ */
+export declare const specEmail: () => EmailSpec;
+export declare const QueueSpec: Schema.Struct<{
+    kind: Schema.Literal<["queue"]>;
+    queue: Schema.refine<string, typeof Schema.NonEmptyString>;
+}>;
+export type QueueSpec = Schema.Schema.Type<typeof QueueSpec>;
+/**
+ * Construct a Queue trigger spec from a queue DXN string.
+ */
+export declare const specQueue: (queueDxn: string) => QueueSpec;
+/**
+ * Construct a Queue trigger spec from a Feed object.
+ */
+export declare const specFeed: (feed: Feed.Feed) => QueueSpec;
+/**
+ * Subscription.
+ */
+export declare const SubscriptionSpec: Schema.Struct<{
+    kind: Schema.Literal<["subscription"]>;
+    query: Schema.Struct<{
+        raw: Schema.optional<Schema.SchemaClass<string, string, never>>;
+        ast: Schema.Schema<QueryAST.QueryFilterClause | QueryAST.QueryFromClause | QueryAST.QueryHierarchyTraversalClause | QueryAST.QueryIncomingReferencesClause | QueryAST.QueryLimitClause | QueryAST.QueryOptionsClause | QueryAST.QueryOrderClause | QueryAST.QueryReferenceTraversalClause | QueryAST.QueryRelationClause | QueryAST.QueryRelationTraversalClause | QueryAST.QuerySelectClause | QueryAST.QuerySetDifferenceClause | QueryAST.QueryUnionClause, QueryAST.QueryFilterClause | QueryAST.QueryFromClause | QueryAST.QueryHierarchyTraversalClause | QueryAST.QueryIncomingReferencesClause | QueryAST.QueryLimitClause | QueryAST.QueryOptionsClause | QueryAST.QueryOrderClause | QueryAST.QueryReferenceTraversalClause | QueryAST.QueryRelationClause | QueryAST.QueryRelationTraversalClause | QueryAST.QuerySelectClause | QueryAST.QuerySetDifferenceClause | QueryAST.QueryUnionClause, never>;
+    }>;
+    options: Schema.optional<Schema.Struct<{
+        deep: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
+        delay: Schema.optional<Schema.SchemaClass<number, number, never>>;
+    }>>;
+}>;
+export type SubscriptionSpec = Schema.Schema.Type<typeof SubscriptionSpec>;
+/**
+ * Construct a Subscription trigger spec from a Query object.
+ */
+export declare const specSubscription: (query: Query.Query<any>, options?: {
+    deep?: boolean;
+    delay?: number;
+}) => SubscriptionSpec;
+/**
+ * Cron timer.
+ */
+export declare const TimerSpec: Schema.Struct<{
+    kind: Schema.Literal<["timer"]>;
+    cron: Schema.SchemaClass<string, string, never>;
+}>;
+export type TimerSpec = Schema.Schema.Type<typeof TimerSpec>;
+/**
+ * Construct a Timer trigger spec from a cron string.
+ */
+export declare const specTimer: (cron: string) => TimerSpec;
+/**
+ * Webhook.
+ */
+export declare const WebhookSpec: Schema.Struct<{
+    kind: Schema.Literal<["webhook"]>;
+    method: Schema.optional<Schema.SchemaClass<string, string, never>>;
+    port: Schema.optional<Schema.SchemaClass<number, number, never>>;
+}>;
+export type WebhookSpec = Schema.Schema.Type<typeof WebhookSpec>;
+/**
+ * Construct a Webhook trigger spec from a method and port.
+ */
+export declare const specWebhook: (opts?: {
+    method?: string;
+    port?: number;
+}) => WebhookSpec;
+/**
+ * Trigger schema.
+ */
+export declare const Spec: Schema.Union<[Schema.Struct<{
+    kind: Schema.Literal<["email"]>;
+}>, Schema.Struct<{
+    kind: Schema.Literal<["queue"]>;
+    queue: Schema.refine<string, typeof Schema.NonEmptyString>;
+}>, Schema.Struct<{
+    kind: Schema.Literal<["subscription"]>;
+    query: Schema.Struct<{
+        raw: Schema.optional<Schema.SchemaClass<string, string, never>>;
+        ast: Schema.Schema<QueryAST.QueryFilterClause | QueryAST.QueryFromClause | QueryAST.QueryHierarchyTraversalClause | QueryAST.QueryIncomingReferencesClause | QueryAST.QueryLimitClause | QueryAST.QueryOptionsClause | QueryAST.QueryOrderClause | QueryAST.QueryReferenceTraversalClause | QueryAST.QueryRelationClause | QueryAST.QueryRelationTraversalClause | QueryAST.QuerySelectClause | QueryAST.QuerySetDifferenceClause | QueryAST.QueryUnionClause, QueryAST.QueryFilterClause | QueryAST.QueryFromClause | QueryAST.QueryHierarchyTraversalClause | QueryAST.QueryIncomingReferencesClause | QueryAST.QueryLimitClause | QueryAST.QueryOptionsClause | QueryAST.QueryOrderClause | QueryAST.QueryReferenceTraversalClause | QueryAST.QueryRelationClause | QueryAST.QueryRelationTraversalClause | QueryAST.QuerySelectClause | QueryAST.QuerySetDifferenceClause | QueryAST.QueryUnionClause, never>;
+    }>;
+    options: Schema.optional<Schema.Struct<{
+        deep: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
+        delay: Schema.optional<Schema.SchemaClass<number, number, never>>;
+    }>>;
+}>, Schema.Struct<{
+    kind: Schema.Literal<["timer"]>;
+    cron: Schema.SchemaClass<string, string, never>;
+}>, Schema.Struct<{
+    kind: Schema.Literal<["webhook"]>;
+    method: Schema.optional<Schema.SchemaClass<string, string, never>>;
+    port: Schema.optional<Schema.SchemaClass<number, number, never>>;
+}>]>;
+export type Spec = Schema.Schema.Type<typeof Spec>;
+/**
+ * Function trigger.
+ * Function is invoked with the `payload` passed as input data.
+ * The event that triggers the function is available in the function context.
+ */
+declare const TriggerSchema: Type.Obj<{
+    readonly function?: import("@dxos/echo/internal").Ref<import("@dxos/echo/Entity").OfKind<import("@dxos/echo/internal").EntityKind.Object> & Obj.Unknown> | undefined;
+    readonly inputNodeId?: string | undefined;
+    readonly enabled?: boolean | undefined;
+    readonly spec?: {
+        readonly kind: "email";
+    } | {
+        readonly kind: "queue";
+        readonly queue: string;
+    } | {
+        readonly kind: "subscription";
+        readonly query: {
+            readonly raw?: string | undefined;
+            readonly ast: QueryAST.QueryFilterClause | QueryAST.QueryFromClause | QueryAST.QueryHierarchyTraversalClause | QueryAST.QueryIncomingReferencesClause | QueryAST.QueryLimitClause | QueryAST.QueryOptionsClause | QueryAST.QueryOrderClause | QueryAST.QueryReferenceTraversalClause | QueryAST.QueryRelationClause | QueryAST.QueryRelationTraversalClause | QueryAST.QuerySelectClause | QueryAST.QuerySetDifferenceClause | QueryAST.QueryUnionClause;
+        };
+        readonly options?: {
+            readonly deep?: boolean | undefined;
+            readonly delay?: number | undefined;
+        } | undefined;
+    } | {
+        readonly kind: "timer";
+        readonly cron: string;
+    } | {
+        readonly kind: "webhook";
+        readonly method?: string | undefined;
+        readonly port?: number | undefined;
+    } | undefined;
+    readonly concurrency?: number | undefined;
+    readonly input?: {
+        readonly [x: string]: any;
+    } | undefined;
+}, Schema.Struct.Fields>;
+export interface Trigger extends Schema.Schema.Type<typeof TriggerSchema> {
+}
+export declare const Trigger: Type.Obj<Trigger>;
+export declare const make: (props: Obj.MakeProps<typeof Trigger>) => Obj.OfShape<import("@dxos/echo/Entity").OfKind<import("@dxos/echo/internal").EntityKind.Object> & Trigger>;
+export {};
+//# sourceMappingURL=Trigger.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Trigger.d.ts","sourceRoot":"","sources":["../../../src/Trigger.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAGxC,OAAO,EAAc,IAAI,EAAE,GAAG,EAAE,QAAQ,EAAO,IAAI,EAAE,KAAK,KAAK,EAAE,MAAM,YAAY,CAAC;AAKpF;;;;GAIG;AACH,eAAO,MAAM,KAAK,YAAI,OAAO,EAAE,OAAO,EAAE,cAAc,EAAE,OAAO,EAAE,SAAS,CAAU,CAAC;AACrF,MAAM,MAAM,IAAI,GAAG,CAAC,OAAO,KAAK,CAAC,CAAC,MAAM,CAAC,CAAC;AAI1C,eAAO,MAAM,SAAS;;EAEpB,CAAC;AACH,MAAM,MAAM,SAAS,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,SAAS,CAAC,CAAC;AAE7D;;GAEG;AACH,eAAO,MAAM,SAAS,QAAO,SAAgC,CAAC;AAI9D,eAAO,MAAM,SAAS;;;EAKpB,CAAC;AACH,MAAM,MAAM,SAAS,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,SAAS,CAAC,CAAC;AAE7D;;GAEG;AACH,eAAO,MAAM,SAAS,aAAc,MAAM,KAAG,SAG3C,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,QAAQ,SAAU,IAAI,CAAC,IAAI,KAAG,SACqE,CAAC;AAEjH;;GAEG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;EAc3B,CAAC;AACH,MAAM,MAAM,gBAAgB,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE3E;;GAEG;AACH,eAAO,MAAM,gBAAgB,UACpB,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,YACb;IAAE,IAAI,CAAC,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,KAC3C,gBAWD,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,SAAS;;;EAMpB,CAAC;AACH,MAAM,MAAM,SAAS,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,SAAS,CAAC,CAAC;AAE7D;;GAEG;AACH,eAAO,MAAM,SAAS,SAAU,MAAM,KAAG,SAAsC,CAAC;AAEhF;;GAEG;AACH,eAAO,MAAM,WAAW;;;;EAatB,CAAC;AACH,MAAM,MAAM,WAAW,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,WAAW,CAAC,CAAC;AAEjE;;GAEG;AACH,eAAO,MAAM,WAAW,UAAW;IAAE,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,KAAG,WAItE,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;IAEf,CAAC;AACH,MAAM,MAAM,IAAI,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,IAAI,CAAC,CAAC;AAEnD;;;;GAIG;AACH,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAgDlB,CAAC;AAEF,MAAM,WAAW,OAAQ,SAAQ,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,aAAa,CAAC;CAAG;AAC5E,eAAO,MAAM,OAAO,EAAE,IAAI,CAAC,GAAG,CAAC,OAAO,CAAwB,CAAC;AAE/D,eAAO,MAAM,IAAI,UAAW,GAAG,CAAC,SAAS,CAAC,OAAO,OAAO,CAAC,+GAA6B,CAAC"}

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

@@ -0,0 +1,75 @@
+import * as Schema from 'effect/Schema';
+import { Obj, Ref } from '@dxos/echo';
+export declare const EmailEvent: Schema.Struct<{
+    from: typeof Schema.String;
+    to: typeof Schema.String;
+    subject: typeof Schema.String;
+    created: typeof Schema.String;
+    body: typeof Schema.String;
+}>;
+export type EmailEvent = Schema.Schema.Type<typeof EmailEvent>;
+export declare const QueueEvent: Schema.Struct<{
+    queue: Schema.refine<string, typeof Schema.NonEmptyString>;
+    item: typeof Schema.Any;
+    cursor: typeof Schema.String;
+}>;
+export type QueueEvent = Schema.Schema.Type<typeof QueueEvent>;
+export declare const SubscriptionEvent: Schema.Struct<{
+    /**
+     * Type of the mutation.
+     */
+    type: typeof Schema.String;
+    /**
+     * Reference to the object that was changed or created.
+     */
+    subject: Ref.RefSchema<import("@dxos/echo/Entity").OfKind<import("@dxos/echo/internal").EntityKind.Object> & Obj.Unknown>;
+    /**
+     * @deprecated
+     */
+    changedObjectId: Schema.optional<typeof Schema.String>;
+}>;
+export type SubscriptionEvent = Schema.Schema.Type<typeof SubscriptionEvent>;
+export declare const TimerEvent: Schema.Struct<{
+    tick: typeof Schema.Number;
+}>;
+export type TimerEvent = Schema.Schema.Type<typeof TimerEvent>;
+export declare const WebhookEvent: Schema.Struct<{
+    url: typeof Schema.String;
+    method: Schema.Literal<["GET", "POST"]>;
+    headers: Schema.Record$<typeof Schema.String, typeof Schema.String>;
+    bodyText: typeof Schema.String;
+}>;
+export type WebhookEvent = Schema.Schema.Type<typeof WebhookEvent>;
+export declare const TriggerEvent: Schema.Union<[Schema.Struct<{
+    from: typeof Schema.String;
+    to: typeof Schema.String;
+    subject: typeof Schema.String;
+    created: typeof Schema.String;
+    body: typeof Schema.String;
+}>, Schema.Struct<{
+    queue: Schema.refine<string, typeof Schema.NonEmptyString>;
+    item: typeof Schema.Any;
+    cursor: typeof Schema.String;
+}>, Schema.Struct<{
+    /**
+     * Type of the mutation.
+     */
+    type: typeof Schema.String;
+    /**
+     * Reference to the object that was changed or created.
+     */
+    subject: Ref.RefSchema<import("@dxos/echo/Entity").OfKind<import("@dxos/echo/internal").EntityKind.Object> & Obj.Unknown>;
+    /**
+     * @deprecated
+     */
+    changedObjectId: Schema.optional<typeof Schema.String>;
+}>, Schema.Struct<{
+    tick: typeof Schema.Number;
+}>, Schema.Struct<{
+    url: typeof Schema.String;
+    method: Schema.Literal<["GET", "POST"]>;
+    headers: Schema.Record$<typeof Schema.String, typeof Schema.String>;
+    bodyText: typeof Schema.String;
+}>]>;
+export type TriggerEvent = Schema.Schema.Type<typeof TriggerEvent>;
+//# sourceMappingURL=TriggerEvent.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"TriggerEvent.d.ts","sourceRoot":"","sources":["../../../src/TriggerEvent.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAExC,OAAO,EAAO,GAAG,EAAE,GAAG,EAAE,MAAM,YAAY,CAAC;AAQ3C,eAAO,MAAM,UAAU;;;;;;EAMrB,CAAC;AACH,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,UAAU,CAAC,CAAC;AAE/D,eAAO,MAAM,UAAU;;;;EAIrB,CAAC;AACH,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,UAAU,CAAC,CAAC;AAE/D,eAAO,MAAM,iBAAiB;IAC5B;;OAEG;;IAIH;;OAEG;;IAGH;;OAEG;;EAEH,CAAC;AACH,MAAM,MAAM,iBAAiB,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAE7E,eAAO,MAAM,UAAU;;EAAyC,CAAC;AACjE,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,UAAU,CAAC,CAAC;AAE/D,eAAO,MAAM,YAAY;;;;;EAKvB,CAAC;AACH,MAAM,MAAM,YAAY,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,YAAY,CAAC,CAAC;AAEnE,eAAO,MAAM,YAAY;;;;;;;;;;;IA7BvB;;OAEG;;IAIH;;OAEG;;IAGH;;OAEG;;;;;;;;;IAgBwG,CAAC;AAC9G,MAAM,MAAM,YAAY,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,YAAY,CAAC,CAAC"}

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

@@ -0,0 +1,308 @@
+import { BaseError, type BaseErrorOptions } from '@dxos/errors';
+declare const InvokerNotInitializedError_base: {
+    new (options?: BaseErrorOptions): {
+        cause?: unknown;
+        stack?: string;
+        name: "InvokerNotInitializedError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "InvokerNotInitializedError";
+    };
+    isError(error: unknown): error is Error;
+    name: "InvokerNotInitializedError";
+    is(error: unknown): error is BaseError;
+    wrap(options?: Omit<BaseErrorOptions, 'cause'> & {
+        ifTypeDiffers?: boolean;
+    }): (error: unknown) => {
+        cause?: unknown;
+        stack?: string;
+        name: "InvokerNotInitializedError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "InvokerNotInitializedError";
+    };
+    extend<Name extends string = string>(name: Name, message?: string): any;
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
+    stackTraceLimit: number;
+};
+export declare class InvokerNotInitializedError extends InvokerNotInitializedError_base {
+    constructor();
+}
+declare const NoHandlerError_base: {
+    new (options?: BaseErrorOptions): {
+        cause?: unknown;
+        stack?: string;
+        name: "NoHandlerError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "NoHandlerError";
+    };
+    isError(error: unknown): error is Error;
+    name: "NoHandlerError";
+    is(error: unknown): error is BaseError;
+    wrap(options?: Omit<BaseErrorOptions, 'cause'> & {
+        ifTypeDiffers?: boolean;
+    }): (error: unknown) => {
+        cause?: unknown;
+        stack?: string;
+        name: "NoHandlerError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "NoHandlerError";
+    };
+    extend<Name extends string = string>(name: Name, message?: string): any;
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
+    stackTraceLimit: number;
+};
+export declare class NoHandlerError extends NoHandlerError_base {
+    constructor(operationKey: string);
+}
+declare const ServiceNotAvailableError_base: {
+    new (options?: BaseErrorOptions): {
+        cause?: unknown;
+        stack?: string;
+        name: "ServiceNotAvailable";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "ServiceNotAvailable";
+    };
+    isError(error: unknown): error is Error;
+    name: "ServiceNotAvailable";
+    is(error: unknown): error is BaseError;
+    wrap(options?: Omit<BaseErrorOptions, 'cause'> & {
+        ifTypeDiffers?: boolean;
+    }): (error: unknown) => {
+        cause?: unknown;
+        stack?: string;
+        name: "ServiceNotAvailable";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "ServiceNotAvailable";
+    };
+    extend<Name extends string = string>(name: Name, message?: string): any;
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
+    stackTraceLimit: number;
+};
+export declare class ServiceNotAvailableError extends ServiceNotAvailableError_base {
+    constructor(service: string, options?: Omit<BaseErrorOptions, 'context'>);
+}
+declare const FunctionNotFoundError_base: {
+    new (options?: BaseErrorOptions): {
+        cause?: unknown;
+        stack?: string;
+        name: "FunctionNotFound";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "FunctionNotFound";
+    };
+    isError(error: unknown): error is Error;
+    name: "FunctionNotFound";
+    is(error: unknown): error is BaseError;
+    wrap(options?: Omit<BaseErrorOptions, 'cause'> & {
+        ifTypeDiffers?: boolean;
+    }): (error: unknown) => {
+        cause?: unknown;
+        stack?: string;
+        name: "FunctionNotFound";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "FunctionNotFound";
+    };
+    extend<Name extends string = string>(name: Name, message?: string): any;
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
+    stackTraceLimit: number;
+};
+export declare class FunctionNotFoundError extends FunctionNotFoundError_base {
+    constructor(functionKey: string, options?: Omit<BaseErrorOptions, 'context'>);
+}
+declare const FunctionError_base: {
+    new (options?: BaseErrorOptions): {
+        cause?: unknown;
+        stack?: string;
+        name: "FunctionError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "FunctionError";
+    };
+    isError(error: unknown): error is Error;
+    name: "FunctionError";
+    is(error: unknown): error is BaseError;
+    wrap(options?: Omit<BaseErrorOptions, 'cause'> & {
+        ifTypeDiffers?: boolean;
+    }): (error: unknown) => {
+        cause?: unknown;
+        stack?: string;
+        name: "FunctionError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "FunctionError";
+    };
+    extend<Name extends string = string>(name: Name, message?: string): any;
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
+    stackTraceLimit: number;
+};
+export declare class FunctionError extends FunctionError_base {
+}
+declare const InvalidOperationInputError_base: {
+    new (options?: BaseErrorOptions): {
+        cause?: unknown;
+        stack?: string;
+        name: "InvalidOperationInput";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "InvalidOperationInput";
+    };
+    isError(error: unknown): error is Error;
+    name: "InvalidOperationInput";
+    is(error: unknown): error is BaseError;
+    wrap(options?: Omit<BaseErrorOptions, 'cause'> & {
+        ifTypeDiffers?: boolean;
+    }): (error: unknown) => {
+        cause?: unknown;
+        stack?: string;
+        name: "InvalidOperationInput";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "InvalidOperationInput";
+    };
+    extend<Name extends string = string>(name: Name, message?: string): any;
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
+    stackTraceLimit: number;
+};
+export declare class InvalidOperationInputError extends InvalidOperationInputError_base {
+}
+declare const InvalidOperationOutputError_base: {
+    new (options?: BaseErrorOptions): {
+        cause?: unknown;
+        stack?: string;
+        name: "InvalidOperationOutput";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "InvalidOperationOutput";
+    };
+    isError(error: unknown): error is Error;
+    name: "InvalidOperationOutput";
+    is(error: unknown): error is BaseError;
+    wrap(options?: Omit<BaseErrorOptions, 'cause'> & {
+        ifTypeDiffers?: boolean;
+    }): (error: unknown) => {
+        cause?: unknown;
+        stack?: string;
+        name: "InvalidOperationOutput";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "InvalidOperationOutput";
+    };
+    extend<Name extends string = string>(name: Name, message?: string): any;
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
+    stackTraceLimit: number;
+};
+export declare class InvalidOperationOutputError extends InvalidOperationOutputError_base {
+}
+declare const TriggerStateNotFoundError_base: {
+    new (options?: BaseErrorOptions): {
+        cause?: unknown;
+        stack?: string;
+        name: "TriggerStateNotFound";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "TriggerStateNotFound";
+    };
+    isError(error: unknown): error is Error;
+    name: "TriggerStateNotFound";
+    is(error: unknown): error is BaseError;
+    wrap(options?: Omit<BaseErrorOptions, 'cause'> & {
+        ifTypeDiffers?: boolean;
+    }): (error: unknown) => {
+        cause?: unknown;
+        stack?: string;
+        name: "TriggerStateNotFound";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "TriggerStateNotFound";
+    };
+    extend<Name extends string = string>(name: Name, message?: string): any;
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
+    stackTraceLimit: number;
+};
+export declare class TriggerStateNotFoundError extends TriggerStateNotFoundError_base {
+}
+declare const FunctionsAiUpstreamError_base: {
+    new (options?: BaseErrorOptions): {
+        cause?: unknown;
+        stack?: string;
+        name: "FunctionsAiUpstreamError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "FunctionsAiUpstreamError";
+    };
+    isError(error: unknown): error is Error;
+    name: "FunctionsAiUpstreamError";
+    is(error: unknown): error is BaseError;
+    wrap(options?: Omit<BaseErrorOptions, 'cause'> & {
+        ifTypeDiffers?: boolean;
+    }): (error: unknown) => {
+        cause?: unknown;
+        stack?: string;
+        name: "FunctionsAiUpstreamError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "FunctionsAiUpstreamError";
+    };
+    extend<Name extends string = string>(name: Name, message?: string): any;
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
+    stackTraceLimit: number;
+};
+/**
+ * Raised when the upstream AI gateway responds with a structured JSON error envelope
+ * (`{ "type": "error", "error": { "type": ..., "message": ... } }`). Surfaces as a typed
+ * defect from `FunctionsAiHttpClient`, bypassing `@effect/ai`'s generic `HttpResponseError`
+ * wrapping so callers can match on the error class directly.
+ */
+export declare class FunctionsAiUpstreamError extends FunctionsAiUpstreamError_base {
+}
+declare const FunctionsAiMemoizationMissError_base: {
+    new (options?: BaseErrorOptions): {
+        cause?: unknown;
+        stack?: string;
+        name: "FunctionsAiMemoizationMissError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "FunctionsAiMemoizationMissError";
+    };
+    isError(error: unknown): error is Error;
+    name: "FunctionsAiMemoizationMissError";
+    is(error: unknown): error is BaseError;
+    wrap(options?: Omit<BaseErrorOptions, 'cause'> & {
+        ifTypeDiffers?: boolean;
+    }): (error: unknown) => {
+        cause?: unknown;
+        stack?: string;
+        name: "FunctionsAiMemoizationMissError";
+        context: Record<string, unknown>;
+        readonly message: string;
+        readonly _tag: "FunctionsAiMemoizationMissError";
+    };
+    extend<Name extends string = string>(name: Name, message?: string): any;
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
+    stackTraceLimit: number;
+};
+/**
+ * Specialized `FunctionsAiUpstreamError` for the memoization layer: the recorded fixture for a
+ * given cache key was not found and `ALLOW_LLM_GENERATION` is unset. The `cacheKey` is exposed
+ * via `context.cacheKey` to make regeneration straightforward.
+ */
+export declare class FunctionsAiMemoizationMissError extends FunctionsAiMemoizationMissError_base {
+}
+export {};
+//# sourceMappingURL=errors.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../src/errors.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,SAAS,EAAE,KAAK,gBAAgB,EAAE,MAAM,cAAc,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAIhE,qBAAa,0BAA2B,SAAQ,+BAG/C;IACC,cAEC;CACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAED,qBAAa,cAAe,SAAQ,mBAAsE;IACxG,YAAY,YAAY,EAAE,MAAM,EAE/B;CACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAID,qBAAa,wBAAyB,SAAQ,6BAAgE;IAC5G,YAAY,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,IAAI,CAAC,gBAAgB,EAAE,SAAS,CAAC,EAEvE;CACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAED,qBAAa,qBAAsB,SAAQ,0BAA0D;IACnG,YAAY,WAAW,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,IAAI,CAAC,gBAAgB,EAAE,SAAS,CAAC,EAE3E;CACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAED,qBAAa,aAAc,SAAQ,kBAA8D;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEpG,qBAAa,0BAA2B,SAAQ,+BAG/C;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEJ,qBAAa,2BAA4B,SAAQ,gCAGhD;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEJ,qBAAa,yBAA0B,SAAQ,8BAAmE;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAErH;;;;;GAKG;AACH,qBAAa,wBAAyB,SAAQ,6BAG7C;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEJ;;;;GAIG;AACH,qBAAa,+BAAgC,SAAQ,oCAGpD;CAAG"}

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

@@ -1,6 +1,17 @@
-export * from './compute-graph';
-export * from './compute-graph-registry';
-export * from './compute-node';
-export * from './functions';
-export * from './types';
+export * from './errors';
+export * as Blueprint from './Blueprint';
+export * as Credential from './Credential';
+export * as McpServer from './McpServer';
+export * as Operation from './Operation';
+export * as OperationHandlerSet from './OperationHandlerSet';
+export * as OperationRegistry from './OperationRegistry';
+export * as Process from './Process';
+export * as Routine from './Routine';
+export * as Script from './Script';
+export * as ServiceResolver from './ServiceResolver';
+export * as StorageService from './StorageService';
+export * as Template from './Template';
+export * as Trace from './Trace';
+export * as Trigger from './Trigger';
+export * as TriggerEvent from './TriggerEvent';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.ts"],"names":[],"mappings":"AA+BA,cAAc,iBAAiB,CAAC;AAChC,cAAc,0BAA0B,CAAC;AACzC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,aAAa,CAAC;AAC5B,cAAc,SAAS,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.ts"],"names":[],"mappings":"AAIA,cAAc,UAAU,CAAC;AAEzB,OAAO,KAAK,SAAS,MAAM,aAAa,CAAC;AACzC,OAAO,KAAK,UAAU,MAAM,cAAc,CAAC;AAC3C,OAAO,KAAK,SAAS,MAAM,aAAa,CAAC;AACzC,OAAO,KAAK,SAAS,MAAM,aAAa,CAAC;AACzC,OAAO,KAAK,mBAAmB,MAAM,uBAAuB,CAAC;AAC7D,OAAO,KAAK,iBAAiB,MAAM,qBAAqB,CAAC;AACzD,OAAO,KAAK,OAAO,MAAM,WAAW,CAAC;AACrC,OAAO,KAAK,OAAO,MAAM,WAAW,CAAC;AACrC,OAAO,KAAK,MAAM,MAAM,UAAU,CAAC;AACnC,OAAO,KAAK,eAAe,MAAM,mBAAmB,CAAC;AACrD,OAAO,KAAK,cAAc,MAAM,kBAAkB,CAAC;AACnD,OAAO,KAAK,QAAQ,MAAM,YAAY,CAAC;AACvC,OAAO,KAAK,KAAK,MAAM,SAAS,CAAC;AACjC,OAAO,KAAK,OAAO,MAAM,WAAW,CAAC;AACrC,OAAO,KAAK,YAAY,MAAM,gBAAgB,CAAC"}

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

@@ -0,0 +1,11 @@
+import * as Operation from '../Operation';
+export declare const Fibonacci: Operation.Definition<{
+    readonly iterations?: number | undefined;
+}, {
+    readonly result: string;
+}, never>;
+export declare const Reply: Operation.Definition<any, any, never>;
+export declare const Sleep: Operation.Definition<{
+    readonly duration?: number | undefined;
+}, void, never>;
+//# sourceMappingURL=definitions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"definitions.d.ts","sourceRoot":"","sources":["../../../../src/testing/definitions.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,SAAS,MAAM,cAAc,CAAC;AAE1C,eAAO,MAAM,SAAS;;;;SAeM,CAAC;AAE7B,eAAO,MAAM,KAAK,uCAQU,CAAC;AAE7B,eAAO,MAAM,KAAK;;eAaU,CAAC"}

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

@@ -0,0 +1,8 @@
+import * as Operation from '../Operation';
+declare const _default: Operation.WithHandler<Operation.Definition<{
+    readonly iterations?: number | undefined;
+}, {
+    readonly result: string;
+}, never>>;
+export default _default;
+//# sourceMappingURL=fib.d.ts.map

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

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

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

@@ -1,4 +1,7 @@
-export * from './test-builder';
-export * from './test-plugin';
-export * from './util';
+import * as OperationHandlerSet from '../OperationHandlerSet';
+export { Fibonacci, Reply, Sleep } from './definitions';
+export { default as FibonacciHandler } from './fib';
+export { default as ReplyHandler } from './reply';
+export { default as SleepHandler } from './sleep';
+export declare const ExampleHandlers: OperationHandlerSet.OperationHandlerSet;
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/testing/index.ts"],"names":[],"mappings":"AAIA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,eAAe,CAAC;AAC9B,cAAc,QAAQ,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/testing/index.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,mBAAmB,MAAM,wBAAwB,CAAC;AAE9D,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AACxD,OAAO,EAAE,OAAO,IAAI,gBAAgB,EAAE,MAAM,OAAO,CAAC;AACpD,OAAO,EAAE,OAAO,IAAI,YAAY,EAAE,MAAM,SAAS,CAAC;AAClD,OAAO,EAAE,OAAO,IAAI,YAAY,EAAE,MAAM,SAAS,CAAC;AAElD,eAAO,MAAM,eAAe,yCAI3B,CAAC"}

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

@@ -0,0 +1,4 @@
+import * as Operation from '../Operation';
+declare const _default: Operation.WithHandler<Operation.Definition<any, any, never>>;
+export default _default;
+//# sourceMappingURL=reply.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"reply.d.ts","sourceRoot":"","sources":["../../../../src/testing/reply.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,SAAS,MAAM,cAAc,CAAC"}

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

@@ -0,0 +1,6 @@
+import * as Operation from '../Operation';
+declare const _default: Operation.WithHandler<Operation.Definition<{
+    readonly duration?: number | undefined;
+}, void, never>>;
+export default _default;
+//# sourceMappingURL=sleep.d.ts.map

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

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

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

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

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

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