@pikku/cli 0.11.3 → 0.12.1

package/dist/.pikku/trigger/pikku-trigger-types.gen.d.ts

@@ -0,0 +1,113 @@
+/**
+ * This file was generated by @pikku/cli@0.12.1
+ */
+/**
+ * Trigger-specific type definitions for tree-shaking optimization
+ */
+import { CorePikkuTriggerFunction, CorePikkuTriggerFunctionConfig, CoreTrigger } from '@pikku/core/trigger';
+import type { CoreNodeConfig } from '@pikku/core/node';
+import type { SingletonServices } from '../../types/application-types.d.js';
+import type { StandardSchemaV1 } from '@standard-schema/spec';
+/**
+ * A trigger function that sets up a subscription and returns a teardown function.
+ * The trigger is fired via wire.trigger.invoke(data).
+ *
+ * @template TInput - Input type (configuration passed when wired)
+ * @template TOutput - Output type produced when trigger fires
+ */
+export type PikkuTriggerFunction<TInput = unknown, TOutput = unknown> = CorePikkuTriggerFunction<TInput, TOutput, SingletonServices>;
+/**
+ * Configuration object for creating a trigger function with metadata
+ */
+export type PikkuTriggerFunctionConfig<TInput = unknown, TOutput = unknown, InputSchema extends StandardSchemaV1 | undefined = undefined, OutputSchema extends StandardSchemaV1 | undefined = undefined> = CorePikkuTriggerFunctionConfig<TInput, TOutput, SingletonServices, InputSchema, OutputSchema>;
+/**
+ * Helper type to infer the output type from a Standard Schema
+ */
+type InferSchemaOutput<T> = T extends StandardSchemaV1<any, infer Output> ? Output : never;
+/**
+ * Configuration object for trigger functions with Zod schema validation.
+ * Use this when you want to define input/output schemas using Zod.
+ * Types are automatically inferred from the schemas.
+ */
+export type PikkuTriggerFunctionConfigWithSchema<InputSchema extends StandardSchemaV1, OutputSchema extends StandardSchemaV1 | undefined = undefined> = {
+    title?: string;
+    description?: string;
+    tags?: string[];
+    func: PikkuTriggerFunction<InferSchemaOutput<InputSchema>, OutputSchema extends StandardSchemaV1 ? InferSchemaOutput<OutputSchema> : unknown>;
+    input: InputSchema;
+    output?: OutputSchema;
+    node?: CoreNodeConfig;
+};
+/**
+ * Type definition for trigger wirings.
+ * Declares a trigger name and its target pikku function.
+ */
+export type TriggerWiring = CoreTrigger;
+/**
+ * A trigger source with the subscription function, using project-specific services.
+ *
+ * @template TInput - Input type passed to the trigger function
+ * @template TOutput - Output type produced when trigger fires
+ */
+export type TriggerSource<TInput = unknown, TOutput = unknown> = {
+    name: string;
+    func: PikkuTriggerFunctionConfig<TInput, TOutput>;
+} & (unknown extends TInput ? {
+    input?: TInput;
+} : {
+    input: TInput;
+});
+/**
+ * Creates a trigger function configuration.
+ * Use this to define trigger functions that set up subscriptions.
+ *
+ * @param triggerOrConfig - Function definition or configuration object
+ * @returns The normalized configuration object
+ *
+ * @example
+ * ```typescript
+ * export const redisSubscribeTrigger = pikkuTriggerFunc<
+ *   { channel: string },
+ *   { message: string }
+ * >(async ({ redis }, { channel }, { trigger }) => {
+ *   const subscriber = redis.duplicate()
+ *   await subscriber.subscribe(channel, (msg) => {
+ *     trigger.invoke({ message: msg })
+ *   })
+ *   return () => subscriber.unsubscribe()
+ * })
+ *
+ * export const redisSubscribeTrigger = pikkuTriggerFunc({
+ *   title: 'Redis Subscribe Trigger',
+ *   description: 'Listens to Redis pub/sub channel',
+ *   input: z.object({ channel: z.string() }),
+ *   output: z.object({ message: z.string() }),
+ *   func: async ({ redis }, { channel }, { trigger }) => {
+ *     const subscriber = redis.duplicate()
+ *     await subscriber.subscribe(channel, (msg) => {
+ *       trigger.invoke({ message: msg })
+ *     })
+ *     return () => subscriber.unsubscribe()
+ *   }
+ * })
+ * ```
+ */
+export declare function pikkuTriggerFunc<InputSchema extends StandardSchemaV1, OutputSchema extends StandardSchemaV1 | undefined = undefined>(config: PikkuTriggerFunctionConfigWithSchema<InputSchema, OutputSchema>): PikkuTriggerFunctionConfig<InferSchemaOutput<InputSchema>, OutputSchema extends StandardSchemaV1 ? InferSchemaOutput<OutputSchema> : unknown, InputSchema, OutputSchema>;
+export declare function pikkuTriggerFunc<TInput, TOutput = unknown>(triggerOrConfig: PikkuTriggerFunction<TInput, TOutput> | PikkuTriggerFunctionConfig<TInput, TOutput>): PikkuTriggerFunctionConfig<TInput, TOutput>;
+/**
+ * Registers a trigger with the Pikku framework.
+ * Declares a trigger name and its target pikku function.
+ * Runs everywhere — inspector extracts at build time.
+ *
+ * @param trigger - Trigger definition with name and function config
+ */
+export declare const wireTrigger: (trigger: TriggerWiring) => void;
+/**
+ * Registers a trigger source with the Pikku framework.
+ * Provides the subscription function and input data.
+ * Only imported in the trigger worker process.
+ *
+ * @param source - Trigger source with name, func, and input
+ */
+export declare const wireTriggerSource: <TInput = unknown, TOutput = unknown>(source: TriggerSource<TInput, TOutput>) => void;
+export {};

package/dist/.pikku/trigger/pikku-trigger-types.gen.js

@@ -0,0 +1,33 @@
+/**
+ * This file was generated by @pikku/cli@0.12.1
+ */
+/**
+ * Trigger-specific type definitions for tree-shaking optimization
+ */
+import { wireTrigger as wireTriggerCore, wireTriggerSource as wireTriggerSourceCore } from '@pikku/core/trigger';
+export function pikkuTriggerFunc(triggerOrConfig) {
+    if (typeof triggerOrConfig === 'function') {
+        return { func: triggerOrConfig };
+    }
+    return triggerOrConfig;
+}
+/**
+ * Registers a trigger with the Pikku framework.
+ * Declares a trigger name and its target pikku function.
+ * Runs everywhere — inspector extracts at build time.
+ *
+ * @param trigger - Trigger definition with name and function config
+ */
+export const wireTrigger = (trigger) => {
+    wireTriggerCore(trigger);
+};
+/**
+ * Registers a trigger source with the Pikku framework.
+ * Provides the subscription function and input data.
+ * Only imported in the trigger worker process.
+ *
+ * @param source - Trigger source with name, func, and input
+ */
+export const wireTriggerSource = (source) => {
+    wireTriggerSourceCore(source);
+};

package/dist/.pikku/variables/pikku-variable-types.gen.d.ts

@@ -0,0 +1,5 @@
+/**
+ * This file was generated by @pikku/cli@0.12.1
+ */
+export { wireVariable } from '@pikku/core/variable';
+export type { CoreVariable, VariableDefinitionMeta, VariableDefinitionsMeta } from '@pikku/core/variable';

package/dist/.pikku/variables/pikku-variable-types.gen.js

@@ -0,0 +1,4 @@
+/**
+ * This file was generated by @pikku/cli@0.12.1
+ */
+export { wireVariable } from '@pikku/core/variable';

package/dist/.pikku/variables/pikku-variables.gen.d.ts

@@ -0,0 +1,11 @@
+/**
+ * This file was generated by @pikku/cli@0.12.1
+ */
+import { TypedVariablesService as CoreTypedVariablesService } from '@pikku/core/services';
+import type { VariablesService } from '@pikku/core/services';
+export interface VariablesMap {
+}
+export type VariableId = keyof VariablesMap;
+export declare class TypedVariablesService extends CoreTypedVariablesService<VariablesMap> {
+    constructor(variables: VariablesService);
+}

package/dist/.pikku/variables/pikku-variables.gen.js

@@ -0,0 +1,10 @@
+/**
+ * This file was generated by @pikku/cli@0.12.1
+ */
+import { TypedVariablesService as CoreTypedVariablesService } from '@pikku/core/services';
+const VARIABLES_META = {};
+export class TypedVariablesService extends CoreTypedVariablesService {
+    constructor(variables) {
+        super(variables, VARIABLES_META);
+    }
+}

package/dist/.pikku/workflow/pikku-workflow-types.gen.d.ts

@@ -1,146 +1,28 @@
 /**
- * This file was generated by @pikku/cli@0.11.3
+ * This file was generated by @pikku/cli@0.12.1
  */
-/**
- * Workflow type definitions and helpers
- * Used for authoring both DSL and graph-based workflows
- */
-import { PikkuWorkflowWire, WorkflowStepOptions, WorkflowCancelledException } from '@pikku/core/workflow';
+import { WorkflowCancelledException } from '@pikku/core/workflow';
+import { template } from '@pikku/core/workflow';
+import { type PikkuWorkflowGraphConfig, type PikkuWorkflowGraphResult } from '@pikku/core/workflow';
+import type { PikkuWorkflowWire, WorkflowStepOptions } from '@pikku/core/workflow';
 export { WorkflowCancelledException };
 import type { PikkuFunctionSessionless, PikkuFunctionConfig } from '../function/pikku-function-types.gen.js';
 import type { RPCMap, FlattenedRPCMap } from '../rpc/pikku-rpc-wirings-map.internal.gen.d.js';
-import type { GraphNodeConfig, HTTPMethod } from '@pikku/core';
-/**
- * Typed workflow wire with RPC awareness
- * Provides type-safe workflow.do() for RPC steps
- */
+import type { WorkflowMap, GraphsMap } from './pikku-workflow-map.gen.d.js';
+export { template };
 export interface TypedWorkflow extends PikkuWorkflowWire {
     do<K extends keyof RPCMap>(stepName: string, rpcName: K, data: RPCMap[K]['input'], options?: WorkflowStepOptions): Promise<RPCMap[K]['output']>;
     do<T>(stepName: string, fn: () => T | Promise<T>, options?: WorkflowStepOptions): Promise<T>;
 }
-/**
- * Workflow function type with typed workflow service
- */
 export type PikkuFunctionWorkflow<In = unknown, Out = never> = PikkuFunctionSessionless<In, Out, 'workflow'>;
-/**
- * Creates a DSL-compatible workflow function (serializable, shows in Forge UI)
- */
 export declare const pikkuWorkflowFunc: <In, Out = unknown>(func: PikkuFunctionWorkflow<In, Out> | PikkuFunctionConfig<In, Out, "workflow", PikkuFunctionWorkflow<In, Out>>) => PikkuFunctionConfig<In, Out, "workflow", PikkuFunctionWorkflow<In, Out>>;
-/**
- * Creates a complex workflow function (arbitrary code, hidden from Forge UI)
- */
 export declare const pikkuWorkflowComplexFunc: <In, Out = unknown>(func: PikkuFunctionWorkflow<In, Out> | PikkuFunctionConfig<In, Out, "workflow", PikkuFunctionWorkflow<In, Out>>) => PikkuFunctionConfig<In, Out, "workflow", PikkuFunctionWorkflow<In, Out>>;
-/** HTTP wire configuration for graph workflows */
-interface GraphHttpWire<NodeIds extends string> {
-    route: string;
-    method: HTTPMethod;
-    startNode: NodeIds;
-}
-/** Channel wire configuration for graph workflows */
-interface GraphChannelWire<NodeIds extends string> {
-    name: string;
-    onConnect?: NodeIds;
-    onDisconnect?: NodeIds;
-    onMessage?: NodeIds;
-}
-/** Queue wire configuration for graph workflows */
-interface GraphQueueWire<NodeIds extends string> {
-    name: string;
-    startNode: NodeIds;
-}
-/** CLI wire configuration for graph workflows */
-interface GraphCliWire<NodeIds extends string> {
-    command: string;
-    startNode: NodeIds;
-}
-/** MCP wire configurations for graph workflows */
-interface GraphMcpWires<NodeIds extends string> {
-    tool?: Array<{
-        name: string;
-        startNode: NodeIds;
-    }>;
-    prompt?: Array<{
-        name: string;
-        startNode: NodeIds;
-    }>;
-    resource?: Array<{
-        uri: string;
-        startNode: NodeIds;
-    }>;
-}
-/** Schedule wire configuration for graph workflows */
-interface GraphScheduleWire<NodeIds extends string> {
-    cron?: string;
-    interval?: string;
-    startNode: NodeIds;
-}
-/** Trigger wire configuration for graph workflows */
-interface GraphTriggerWire<NodeIds extends string> {
-    name: string;
-    startNode: NodeIds;
-}
-/** All wire configurations for graph workflows */
-interface GraphWiresConfig<NodeIds extends string> {
-    http?: Array<GraphHttpWire<NodeIds>>;
-    channel?: Array<GraphChannelWire<NodeIds>>;
-    queue?: Array<GraphQueueWire<NodeIds>>;
-    cli?: Array<GraphCliWire<NodeIds>>;
-    mcp?: GraphMcpWires<NodeIds>;
-    schedule?: Array<GraphScheduleWire<NodeIds>>;
-    trigger?: Array<GraphTriggerWire<NodeIds>>;
-}
-/** Configuration for graph-based workflow */
-export interface PikkuWorkflowGraphConfig<FuncMap extends Record<string, keyof FlattenedRPCMap & string>, T> {
-    /** Workflow name (optional - defaults to exported variable name) */
-    name?: string;
-    /** Optional description */
-    description?: string;
-    /** Optional tags for organization */
-    tags?: string[];
-    /** Node to RPC function mapping */
-    nodes: FuncMap;
-    /** Wire configurations - how this workflow can be triggered */
-    wires?: GraphWiresConfig<Extract<keyof FuncMap, string>>;
-    /** Node configurations (next, input, onError) */
-    config?: T;
-}
-/** Result of pikkuWorkflowGraph - includes metadata for wiring */
-export interface PikkuWorkflowGraphResult<T, NodeIds extends string = string> {
-    __type: 'pikkuWorkflowGraph';
-    name?: string;
-    description?: string;
-    tags?: string[];
-    wires?: GraphWiresConfig<NodeIds>;
-    graph: T;
-}
-/**
- * Creates a graph-based workflow definition with metadata
- * Name defaults to the exported variable name if not provided.
- *
- * @example
- * // Name inferred from exported variable name
- * export const myWorkflow = pikkuWorkflowGraph({
- *   description: 'Handles user onboarding',
- *   tags: ['onboarding'],
- *   nodes: {
- *     entry: 'createUser',
- *     sendEmail: 'sendWelcomeEmail',
- *   },
- *   config: {
- *     entry: { next: 'sendEmail' },
- *     sendEmail: { input: (ref) => ({ to: ref('entry', 'email') }) },
- *   },
- * })
- */
-export declare function pikkuWorkflowGraph<const FuncMap extends Record<string, keyof FlattenedRPCMap & string>>(config: PikkuWorkflowGraphConfig<FuncMap, GraphNodeConfigMap<FuncMap>>): PikkuWorkflowGraphResult<Record<Extract<keyof FuncMap, string>, GraphNodeConfig<Extract<keyof FuncMap, string>>>, Extract<keyof FuncMap, string>>;
-/** Typed ref value */
 type TypedRef<T> = {
     $ref: string;
     path?: string;
 } & {
     __phantomType?: T;
 };
-/** Template string type - assignable to string fields */
 type TemplateString = {
     $template: {
         parts: string[];
@@ -152,30 +34,16 @@ type TemplateString = {
 } & {
     __brand: 'TemplateString';
 };
-/**
- * Creates a template string with variable interpolation
- * Uses indexed placeholders $0, $1, etc. with refs array
- *
- * @example
- * template('Hello $0, your order $1 is ready', [ref('trigger', 'name'), ref('step_0', 'orderId')])
- */
-export declare function template(templateStr: string, refs: TypedRef<unknown>[]): TemplateString;
-/** Map input type fields to allow TypedRef or TemplateString for any field */
 type InputWithRefs<T> = {
     [K in keyof T]?: T[K] | TypedRef<T[K]> | TypedRef<unknown> | TemplateString;
 };
-/** Get the input type for a node based on its RPC mapping */
 type NodeInputType<FuncMap extends Record<string, string>, K extends keyof FuncMap> = FuncMap[K] extends keyof FlattenedRPCMap ? InputWithRefs<FlattenedRPCMap[FuncMap[K]]['input']> : Record<string, unknown>;
-/** Get the output type keys for a node based on its RPC mapping */
 type NodeOutputKeys<FuncMap extends Record<string, string>, N extends string> = N extends keyof FuncMap ? FuncMap[N] extends keyof FlattenedRPCMap ? keyof FlattenedRPCMap[FuncMap[N]]['output'] & string : string : string;
-/** Ref function type with path validation */
 type RefFunction<FuncMap extends Record<string, string>> = {
     <N extends Extract<keyof FuncMap, string>>(nodeId: N, path: NodeOutputKeys<FuncMap, N>): TypedRef<unknown>;
     (nodeId: 'trigger' | '$item', path?: string): TypedRef<unknown>;
 };
-/** Template function type */
 type TemplateFunction = (templateStr: string, refs: TypedRef<unknown>[]) => TemplateString;
-/** Type helper for node configuration */
 type GraphNodeConfigMap<FuncMap extends Record<string, string>> = {
     [K in Extract<keyof FuncMap, string>]?: {
         next?: NextConfig<Extract<keyof FuncMap, string>>;
@@ -188,45 +56,25 @@ type NextConfig<NodeIds extends string> = NodeIds | NodeIds[] | {
     then: NodeIds;
     else?: NodeIds;
 };
-/** Workflow definition with DSL function */
-interface WorkflowDefinitionFunc {
-    /** Whether this workflow wiring is enabled (default: true) */
-    enabled?: boolean;
-    /** Wire configurations for the workflow */
-    wires: {
-        http?: {
-            route: string;
-            method: HTTPMethod;
-        };
-        channel?: string;
-        queue?: string;
+export declare function pikkuWorkflowGraph<const FuncMap extends Record<string, keyof FlattenedRPCMap & string>>(config: PikkuWorkflowGraphConfig<FuncMap, GraphNodeConfigMap<FuncMap>>): PikkuWorkflowGraphResult;
+export declare const workflow: <Name extends keyof WorkflowMap>(workflowName: Name, options?: {
+    pollIntervalMs?: number;
+}) => PikkuFunctionConfig<WorkflowMap[Name]["input"], WorkflowMap[Name]["output"], "session" | "rpc">;
+export declare const workflowStart: <Name extends keyof WorkflowMap>(workflowName: Name) => PikkuFunctionConfig<WorkflowMap[Name]["input"], {
+    runId: string;
+}, "session" | "rpc">;
+export declare const workflowStatus: <Name extends keyof WorkflowMap>(_workflowName: Name) => PikkuFunctionConfig<{
+    runId: string;
+}, {
+    id: string;
+    status: "running" | "completed" | "failed" | "cancelled";
+    output?: WorkflowMap[Name]["output"];
+    error?: {
+        message?: string;
     };
-    /** DSL workflow function */
-    func: PikkuFunctionConfig<any, any, 'workflow', PikkuFunctionWorkflow<any, any>>;
-}
-/** Workflow definition with graph */
-interface WorkflowDefinitionGraph<T, NodeIds extends string = string> {
-    /** Whether this workflow wiring is enabled (default: true) */
-    enabled?: boolean;
-    /** Graph workflow definition - wires are defined in the graph itself */
-    graph: PikkuWorkflowGraphResult<T, NodeIds>;
-}
-/**
- * Wire a workflow with wires
- * Accepts either a DSL function (func) or a graph definition (graph)
- *
- * @example
- * // DSL workflow
- * wireWorkflow({
- *   wires: { http: { route: '/start', method: 'post' } },
- *   func: myWorkflowFunc,
- * })
- *
- * @example
- * // Graph workflow - wires are defined in the graph itself
- * wireWorkflow({
- *   enabled: true,  // default: true
- *   graph: myGraphWorkflow,
- * })
- */
-export declare function wireWorkflow<T extends Record<string, GraphNodeConfig<Extract<keyof T, string>>>, NodeIds extends string = string>(definition: WorkflowDefinitionFunc | WorkflowDefinitionGraph<T, NodeIds>): void;
+}, "session" | "rpc">;
+export declare const graphStart: <Name extends keyof GraphsMap, Node extends string & keyof GraphsMap[Name]>(graphName: Name, startNode: Node) => PikkuFunctionConfig<GraphsMap[Name][Node] extends {
+    input: infer I;
+} ? I : never, {
+    runId: string;
+}, "session" | "rpc">;

package/dist/.pikku/workflow/pikku-workflow-types.gen.js

@@ -1,118 +1,30 @@
 /**
- * This file was generated by @pikku/cli@0.11.3
- */
-/**
- * Workflow type definitions and helpers
- * Used for authoring both DSL and graph-based workflows
+ * This file was generated by @pikku/cli@0.12.1
  */
 import { WorkflowCancelledException } from '@pikku/core/workflow';
-// Re-export WorkflowCancelledException for use in workflow functions
+import { workflow as coreWorkflow, workflowStart as coreWorkflowStart, workflowStatus as coreWorkflowStatus, graphStart as coreGraphStart, } from '@pikku/core/workflow';
+import { template } from '@pikku/core/workflow';
+import { pikkuWorkflowGraph as corePikkuWorkflowGraph, } from '@pikku/core/workflow';
 export { WorkflowCancelledException };
-import { createGraph, wireWorkflow as coreWireWorkflow } from '@pikku/core';
-/**
- * Creates a DSL-compatible workflow function (serializable, shows in Forge UI)
- */
+export { template };
 export const pikkuWorkflowFunc = (func) => {
     return typeof func === 'function' ? { func } : func;
 };
-/**
- * Creates a complex workflow function (arbitrary code, hidden from Forge UI)
- */
 export const pikkuWorkflowComplexFunc = (func) => {
     return typeof func === 'function' ? { func } : func;
 };
-// ============================================================================
-// Graph Workflow Types (pikkuWorkflowGraph)
-// ============================================================================
-/**
- * Type-safe graph builder with full RPC autocomplete
- */
-const graphBuilder = createGraph();
-/**
- * Creates a graph-based workflow definition with metadata
- * Name defaults to the exported variable name if not provided.
- *
- * @example
- * // Name inferred from exported variable name
- * export const myWorkflow = pikkuWorkflowGraph({
- *   description: 'Handles user onboarding',
- *   tags: ['onboarding'],
- *   nodes: {
- *     entry: 'createUser',
- *     sendEmail: 'sendWelcomeEmail',
- *   },
- *   config: {
- *     entry: { next: 'sendEmail' },
- *     sendEmail: { input: (ref) => ({ to: ref('entry', 'email') }) },
- *   },
- * })
- */
 export function pikkuWorkflowGraph(config) {
-    return {
-        __type: 'pikkuWorkflowGraph',
-        name: config.name,
-        description: config.description,
-        tags: config.tags,
-        wires: config.wires,
-        graph: graphBuilder(config.nodes, config.config),
-    };
-}
-/**
- * Creates a template string with variable interpolation
- * Uses indexed placeholders $0, $1, etc. with refs array
- *
- * @example
- * template('Hello $0, your order $1 is ready', [ref('trigger', 'name'), ref('step_0', 'orderId')])
- */
-export function template(templateStr, refs) {
-    const parts = [];
-    const expressions = [];
-    // Parse template string: "Hello $0" -> parts: ["Hello ", ""], use refs[0] for expression
-    const regex = /$(d+)/g;
-    let lastIndex = 0;
-    let match;
-    while ((match = regex.exec(templateStr)) !== null) {
-        // Add the part before this match
-        parts.push(templateStr.slice(lastIndex, match.index));
-        // Get the ref by index
-        const refIndex = parseInt(match[1], 10);
-        const refValue = refs[refIndex];
-        if (refValue) {
-            const expr = { $ref: refValue.$ref };
-            if (refValue.path) {
-                expr.path = refValue.path;
-            }
-            expressions.push(expr);
-        }
-        else {
-            expressions.push({ $ref: 'unknown' });
-        }
-        lastIndex = regex.lastIndex;
-    }
-    // Add the remaining part
-    parts.push(templateStr.slice(lastIndex));
-    return {
-        $template: { parts, expressions }
-    };
-}
-/**
- * Wire a workflow with wires
- * Accepts either a DSL function (func) or a graph definition (graph)
- *
- * @example
- * // DSL workflow
- * wireWorkflow({
- *   wires: { http: { route: '/start', method: 'post' } },
- *   func: myWorkflowFunc,
- * })
- *
- * @example
- * // Graph workflow - wires are defined in the graph itself
- * wireWorkflow({
- *   enabled: true,  // default: true
- *   graph: myGraphWorkflow,
- * })
- */
-export function wireWorkflow(definition) {
-    coreWireWorkflow(definition);
+    return corePikkuWorkflowGraph(config);
 }
+export const workflow = (workflowName, options) => {
+    return coreWorkflow(workflowName, options);
+};
+export const workflowStart = (workflowName) => {
+    return coreWorkflowStart(workflowName);
+};
+export const workflowStatus = (_workflowName) => {
+    return coreWorkflowStatus(_workflowName);
+};
+export const graphStart = (graphName, startNode) => {
+    return coreGraphStart(graphName, startNode);
+};

package/dist/.pikku/workflow/pikku-workflow-wirings-meta.gen.js

@@ -1,6 +1,6 @@
 /**
- * This file was generated by @pikku/cli@0.11.3
+ * This file was generated by @pikku/cli@0.12.1
  */
-import { pikkuState } from '@pikku/core';
+import { pikkuState } from '@pikku/core/internal';
 const workflowsMeta = {};
 pikkuState(null, 'workflows', 'meta', workflowsMeta);

package/dist/.pikku/workflow/pikku-workflow-wirings.gen.d.ts

@@ -1,4 +1,4 @@
 export {};
 /**
- * This file was generated by @pikku/cli@0.11.3
+ * This file was generated by @pikku/cli@0.12.1
  */

package/dist/.pikku/workflow/pikku-workflow-wirings.gen.js

@@ -1,4 +1,4 @@
 export {};
 /**
- * This file was generated by @pikku/cli@0.11.3
+ * This file was generated by @pikku/cli@0.12.1
  */