@pgflow/dsl 0.0.0-test-snapshot-releases2-8d5d9bc1-20250922101158 → 0.0.0-testsnap-9294d743-20251207205914

package/dist/dsl.js

@@ -0,0 +1,159 @@
+import { validateRuntimeOptions, validateSlug } from './utils.js';
+// Flow class definition
+export class Flow {
+    /**
+     * Store step definitions with their proper types
+     *
+     * This is typed as a generic record because TypeScript cannot track the exact relationship
+     * between step slugs and their corresponding input/output types at the container level.
+     * Type safety is enforced at the method level when adding or retrieving steps.
+     */
+    stepDefinitions;
+    stepOrder;
+    slug;
+    options;
+    constructor(config, stepDefinitions = {}, stepOrder = []) {
+        // Extract slug and options separately
+        const { slug, ...options } = config;
+        // Validate the slug
+        validateSlug(slug);
+        // Validate runtime options (optional for Flow level)
+        validateRuntimeOptions(options, { optional: true });
+        this.slug = slug;
+        this.options = options;
+        this.stepDefinitions = stepDefinitions;
+        // Defensive copy of stepOrder
+        this.stepOrder = [...stepOrder];
+    }
+    /**
+     * Get a specific step definition by slug with proper typing
+     * @throws Error if the step with the given slug doesn't exist
+     */
+    getStepDefinition(slug) {
+        // Check if the slug exists in stepDefinitions using a more explicit pattern
+        if (!(slug in this.stepDefinitions)) {
+            throw new Error(`Step "${String(slug)}" does not exist in flow "${this.slug}"`);
+        }
+        // Use a type assertion directive to tell TypeScript that this is safe
+        // @ts-expect-error The type system cannot track that this.stepDefinitions[slug] has the correct type
+        // but we know it's safe because we only add steps through the strongly-typed `step` method
+        return this.stepDefinitions[slug];
+    }
+    // SlugType extends keyof Steps & keyof StepDependencies
+    step(opts, handler) {
+        const slug = opts.slug;
+        // Validate the step slug
+        validateSlug(slug);
+        if (this.stepDefinitions[slug]) {
+            throw new Error(`Step "${slug}" already exists in flow "${this.slug}"`);
+        }
+        const dependencies = opts.dependsOn || [];
+        // Validate dependencies - check if all referenced steps exist
+        if (dependencies.length > 0) {
+            for (const dep of dependencies) {
+                if (!this.stepDefinitions[dep]) {
+                    throw new Error(`Step "${slug}" depends on undefined step "${dep}"`);
+                }
+            }
+        }
+        // Extract RuntimeOptions from opts
+        const options = {};
+        if (opts.maxAttempts !== undefined)
+            options.maxAttempts = opts.maxAttempts;
+        if (opts.baseDelay !== undefined)
+            options.baseDelay = opts.baseDelay;
+        if (opts.timeout !== undefined)
+            options.timeout = opts.timeout;
+        if (opts.startDelay !== undefined)
+            options.startDelay = opts.startDelay;
+        // Validate runtime options (optional for step level)
+        validateRuntimeOptions(options, { optional: true });
+        // Preserve the exact type of the handler
+        const newStepDefinition = {
+            slug,
+            handler: handler, // Type assertion needed due to complex generic constraints
+            dependencies: dependencies,
+            options,
+        };
+        const newStepDefinitions = {
+            ...this.stepDefinitions,
+            [slug]: newStepDefinition,
+        };
+        // Create a new stepOrder array with the new slug appended
+        const newStepOrder = [...this.stepOrder, slug];
+        // Create a new flow with the same slug and options but with updated type parameters
+        // We need to use type assertions here because TypeScript cannot track the exact relationship
+        // between the specific step definition types and the generic Flow type parameters
+        // This is safe because we're constructing the newStepDefinitions in a type-safe way above
+        return new Flow({ slug: this.slug, ...this.options }, newStepDefinitions, newStepOrder);
+    }
+    /**
+     * Add an array-returning step to the flow with compile-time type safety
+     *
+     * This method provides semantic clarity and type enforcement for steps that return arrays,
+     * while maintaining full compatibility with the existing step system by delegating to `.step()`.
+     *
+     * @template Slug - The unique identifier for this step
+     * @template THandler - The handler function that must return an array or Promise<array>
+     * @template Deps - The step dependencies (must be existing step slugs)
+     * @param opts - Step configuration including slug, dependencies, and runtime options
+     * @param handler - Function that processes input and returns an array (null/undefined rejected)
+     * @returns A new Flow instance with the array step added
+     */
+    array(opts, handler) {
+        // Delegate to existing .step() method for maximum code reuse
+        return this.step(opts, handler);
+    }
+    // Implementation
+    map(opts, handler) {
+        const slug = opts.slug;
+        // Validate the step slug
+        validateSlug(slug);
+        if (this.stepDefinitions[slug]) {
+            throw new Error(`Step "${slug}" already exists in flow "${this.slug}"`);
+        }
+        // Determine dependencies based on whether array is specified
+        let dependencies = [];
+        const arrayDep = opts.array;
+        if (arrayDep) {
+            // Dependent map - validate single dependency exists and returns array
+            if (!this.stepDefinitions[arrayDep]) {
+                throw new Error(`Step "${slug}" depends on undefined step "${arrayDep}"`);
+            }
+            dependencies = [arrayDep];
+        }
+        else {
+            // Root map - flow input must be an array (type system enforces this)
+            dependencies = [];
+        }
+        // Extract runtime options
+        const options = {};
+        if (opts.maxAttempts !== undefined)
+            options.maxAttempts = opts.maxAttempts;
+        if (opts.baseDelay !== undefined)
+            options.baseDelay = opts.baseDelay;
+        if (opts.timeout !== undefined)
+            options.timeout = opts.timeout;
+        if (opts.startDelay !== undefined)
+            options.startDelay = opts.startDelay;
+        // Validate runtime options
+        validateRuntimeOptions(options, { optional: true });
+        // Create the map step definition with stepType
+        // Note: We use AnyInput/AnyOutput here because the actual types are handled at the type level via overloads
+        const newStepDefinition = {
+            slug,
+            handler: handler, // Type assertion needed due to complex generic constraints
+            dependencies,
+            options,
+            stepType: 'map', // Mark this as a map step
+        };
+        const newStepDefinitions = {
+            ...this.stepDefinitions,
+            [slug]: newStepDefinition,
+        };
+        // Create a new stepOrder array with the new slug appended
+        const newStepOrder = [...this.stepOrder, slug];
+        // Create and return new Flow instance with updated types
+        return new Flow({ slug: this.slug, ...this.options }, newStepDefinitions, newStepOrder); // Type assertion handled by overloads
+    }
+}

package/dist/example-flow.d.ts

@@ -0,0 +1,29 @@
+import { Flow } from './dsl.js';
+type Input = {
+    url: string;
+};
+export declare const AnalyzeWebsite: Flow<Input, {}, import("./dsl.js").EmptySteps & {
+    website: {
+        content: string;
+    };
+} & {
+    sentiment: {
+        score: number;
+    };
+} & {
+    summary: {
+        aiSummary: string;
+    };
+} & {
+    saveToDb: string;
+}, import("./dsl.js").EmptyDeps & {
+    website: never[];
+} & {
+    sentiment: "website"[];
+} & {
+    summary: "website"[];
+} & {
+    saveToDb: ("sentiment" | "summary")[];
+}, import("./dsl.js").Env>;
+export {};
+//# sourceMappingURL=example-flow.d.ts.map

package/dist/example-flow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"example-flow.d.ts","sourceRoot":"","sources":["../src/example-flow.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,UAAU,CAAC;AAGhC,KAAK,KAAK,GAAG;IACX,GAAG,EAAE,MAAM,CAAC;CACb,CAAC;AAEF,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;0BA4BxB,CAAC"}

package/dist/example-flow.js

@@ -0,0 +1,41 @@
+import { Flow } from './dsl.js';
+export const AnalyzeWebsite = new Flow({
+    slug: 'analyze_website',
+    maxAttempts: 3,
+    baseDelay: 5,
+    timeout: 10,
+})
+    .step({ slug: 'website' }, async (input) => await scrapeWebsite(input.run.url))
+    .step({ slug: 'sentiment', dependsOn: ['website'], timeout: 30, maxAttempts: 5 }, async (input) => await analyzeSentiment(input.website.content))
+    .step({ slug: 'summary', dependsOn: ['website'] }, async (input) => await summarizeWithAI(input.website.content))
+    .step({ slug: 'saveToDb', dependsOn: ['sentiment', 'summary'] }, async (input) => {
+    const results = await saveToDb({
+        websiteUrl: input.run.url,
+        sentiment: input.sentiment.score,
+        summary: input.summary.aiSummary,
+    });
+    return results.status;
+});
+/***********************************************************************
+ ****** functions *******************************************************
+ ***********************************************************************/
+async function scrapeWebsite(url) {
+    return {
+        content: `Lorem ipsum ${url.length}`,
+    };
+}
+const analyzeSentiment = async (_content) => {
+    return {
+        score: Math.random(),
+    };
+};
+const summarizeWithAI = async (content) => {
+    return {
+        aiSummary: `Lorem ipsum ${content.length}`,
+    };
+};
+const saveToDb = async (_input) => {
+    return {
+        status: 'success',
+    };
+};

package/dist/flow-shape.d.ts

@@ -0,0 +1,81 @@
+import { AnyFlow } from './dsl.js';
+/**
+ * Step-level options that can be included in the shape for creation,
+ * but are NOT compared during shape comparison (runtime tunable).
+ */
+export interface StepShapeOptions {
+    maxAttempts?: number;
+    baseDelay?: number;
+    timeout?: number;
+    startDelay?: number;
+}
+/**
+ * Flow-level options that can be included in the shape for creation,
+ * but are NOT compared during shape comparison (runtime tunable).
+ */
+export interface FlowShapeOptions {
+    maxAttempts?: number;
+    baseDelay?: number;
+    timeout?: number;
+}
+/**
+ * StepShape captures the structural definition of a step for drift detection.
+ *
+ * The `options` field is included for flow creation but NOT compared during
+ * shape comparison. Options can be tuned at runtime via SQL without
+ * requiring recompilation. See: /deploy/tune-flow-config/
+ */
+export interface StepShape {
+    slug: string;
+    stepType: 'single' | 'map';
+    dependencies: string[];
+    options?: StepShapeOptions;
+}
+/**
+ * FlowShape captures the structural definition of a flow for drift detection.
+ *
+ * This represents the DAG topology - which steps exist, their types, and how
+ * they connect via dependencies.
+ *
+ * The `options` field is included for flow creation but NOT compared during
+ * shape comparison. Options can be tuned at runtime via SQL without recompilation.
+ *
+ * Note: flowSlug is intentionally excluded - it's an identifier, not structural
+ * data. The slug comes from context (URL, registry lookup, function parameter).
+ */
+export interface FlowShape {
+    steps: StepShape[];
+    options?: FlowShapeOptions;
+}
+/**
+ * Result of comparing two FlowShapes.
+ */
+export interface ShapeComparisonResult {
+    match: boolean;
+    differences: string[];
+}
+/**
+ * Extracts a FlowShape from a Flow object.
+ * The shape captures structural information needed for drift detection,
+ * plus options for flow creation.
+ *
+ * Options are included in the shape for proper flow/step creation, but
+ * are NOT compared during shape comparison (they're runtime tunable).
+ *
+ * @param flow - The Flow object to extract shape from
+ * @returns A FlowShape representing the flow's structure and options
+ */
+export declare function extractFlowShape(flow: AnyFlow): FlowShape;
+/**
+ * Compares two FlowShapes and returns detailed differences.
+ * Used by ControlPlane for Layer 1 comparison (Worker vs ControlPlane).
+ *
+ * Only compares structural aspects (steps, types, dependencies).
+ * Runtime options are not compared as they can be tuned independently.
+ *
+ * @param a - First FlowShape (typically from worker)
+ * @param b - Second FlowShape (typically from ControlPlane or database)
+ * @returns ShapeComparisonResult with match status and list of differences
+ */
+export declare function compareFlowShapes(a: FlowShape, b: FlowShape): ShapeComparisonResult;
+//# sourceMappingURL=flow-shape.d.ts.map

package/dist/flow-shape.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flow-shape.d.ts","sourceRoot":"","sources":["../src/flow-shape.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,UAAU,CAAC;AAMnC;;;GAGG;AACH,MAAM,WAAW,gBAAgB;IAC/B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;;GAGG;AACH,MAAM,WAAW,gBAAgB;IAC/B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;GAMG;AACH,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,QAAQ,GAAG,KAAK,CAAC;IAC3B,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,OAAO,CAAC,EAAE,gBAAgB,CAAC;CAC5B;AAED;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,SAAS;IACxB,KAAK,EAAE,SAAS,EAAE,CAAC;IACnB,OAAO,CAAC,EAAE,gBAAgB,CAAC;CAC5B;AAED;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC,KAAK,EAAE,OAAO,CAAC;IACf,WAAW,EAAE,MAAM,EAAE,CAAC;CACvB;AAyBD;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,OAAO,GAAG,SAAS,CAwCzD;AAMD;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,CAC/B,CAAC,EAAE,SAAS,EACZ,CAAC,EAAE,SAAS,GACX,qBAAqB,CA6BvB"}

package/dist/flow-shape.js

@@ -0,0 +1,119 @@
+// ========================
+// SHAPE EXTRACTION
+// ========================
+/**
+ * Checks if an options object has any defined (non-undefined) values.
+ */
+function hasDefinedOptions(options) {
+    return Object.values(options).some((v) => v !== undefined);
+}
+/**
+ * Filters out undefined values from an options object.
+ * Returns only the keys with defined values.
+ */
+function filterDefinedOptions(options) {
+    return Object.fromEntries(Object.entries(options).filter(([_, v]) => v !== undefined));
+}
+/**
+ * Extracts a FlowShape from a Flow object.
+ * The shape captures structural information needed for drift detection,
+ * plus options for flow creation.
+ *
+ * Options are included in the shape for proper flow/step creation, but
+ * are NOT compared during shape comparison (they're runtime tunable).
+ *
+ * @param flow - The Flow object to extract shape from
+ * @returns A FlowShape representing the flow's structure and options
+ */
+export function extractFlowShape(flow) {
+    const steps = flow.stepOrder.map((stepSlug) => {
+        const stepDef = flow.getStepDefinition(stepSlug);
+        const stepShape = {
+            slug: stepSlug,
+            stepType: stepDef.stepType ?? 'single',
+            // Sort dependencies alphabetically for deterministic comparison
+            dependencies: [...stepDef.dependencies].sort(),
+        };
+        // Only include options if at least one is defined
+        const stepOptions = {
+            maxAttempts: stepDef.options.maxAttempts,
+            baseDelay: stepDef.options.baseDelay,
+            timeout: stepDef.options.timeout,
+            startDelay: stepDef.options.startDelay,
+        };
+        if (hasDefinedOptions(stepOptions)) {
+            stepShape.options = filterDefinedOptions(stepOptions);
+        }
+        return stepShape;
+    });
+    const shape = { steps };
+    // Only include flow options if at least one is defined
+    const flowOptions = {
+        maxAttempts: flow.options.maxAttempts,
+        baseDelay: flow.options.baseDelay,
+        timeout: flow.options.timeout,
+    };
+    if (hasDefinedOptions(flowOptions)) {
+        shape.options = filterDefinedOptions(flowOptions);
+    }
+    return shape;
+}
+// ========================
+// SHAPE COMPARISON
+// ========================
+/**
+ * Compares two FlowShapes and returns detailed differences.
+ * Used by ControlPlane for Layer 1 comparison (Worker vs ControlPlane).
+ *
+ * Only compares structural aspects (steps, types, dependencies).
+ * Runtime options are not compared as they can be tuned independently.
+ *
+ * @param a - First FlowShape (typically from worker)
+ * @param b - Second FlowShape (typically from ControlPlane or database)
+ * @returns ShapeComparisonResult with match status and list of differences
+ */
+export function compareFlowShapes(a, b) {
+    const differences = [];
+    // Compare step counts
+    if (a.steps.length !== b.steps.length) {
+        differences.push(`Step count differs: ${a.steps.length} vs ${b.steps.length}`);
+    }
+    // Compare steps by index (order matters)
+    const maxLen = Math.max(a.steps.length, b.steps.length);
+    for (let i = 0; i < maxLen; i++) {
+        const aStep = a.steps[i];
+        const bStep = b.steps[i];
+        if (!aStep) {
+            differences.push(`Step at index ${i}: missing in first shape (second has '${bStep.slug}')`);
+        }
+        else if (!bStep) {
+            differences.push(`Step at index ${i}: missing in second shape (first has '${aStep.slug}')`);
+        }
+        else {
+            compareSteps(aStep, bStep, i, differences);
+        }
+    }
+    return {
+        match: differences.length === 0,
+        differences,
+    };
+}
+/**
+ * Compares two steps at the same index and adds differences to the list.
+ */
+function compareSteps(a, b, index, differences) {
+    // Compare slug (order matters, so slugs must match at same index)
+    if (a.slug !== b.slug) {
+        differences.push(`Step at index ${index}: slug differs '${a.slug}' vs '${b.slug}'`);
+    }
+    // Compare step type
+    if (a.stepType !== b.stepType) {
+        differences.push(`Step at index ${index}: type differs '${a.stepType}' vs '${b.stepType}'`);
+    }
+    // Compare dependencies (already sorted)
+    const aDeps = a.dependencies.join(',');
+    const bDeps = b.dependencies.join(',');
+    if (aDeps !== bDeps) {
+        differences.push(`Step at index ${index}: dependencies differ [${a.dependencies.join(', ')}] vs [${b.dependencies.join(', ')}]`);
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * from './dsl.js';
+export * from './compile-flow.js';
+export * from './flow-shape.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,cAAc,mBAAmB,CAAC;AAClC,cAAc,iBAAiB,CAAC"}

package/dist/index.js

@@ -0,0 +1,3 @@
+export * from './dsl.js';
+export * from './compile-flow.js';
+export * from './flow-shape.js';

package/dist/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@pgflow/dsl",
+  "version": "0.0.0-testsnap-9294d743-20251207205914",
+  "license": "Apache-2.0",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "private": false,
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./platforms": {
+      "types": "./dist/platforms/index.d.ts",
+      "import": "./dist/platforms/index.js"
+    },
+    "./supabase": {
+      "types": "./dist/platforms/supabase.d.ts",
+      "import": "./dist/platforms/supabase.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@types/node": "^22.14.1",
+    "postgres": "^3.4.5",
+    "@supabase/supabase-js": "^2.47.10"
+  }
+}

package/dist/platforms/index.d.ts

@@ -0,0 +1,2 @@
+export type { BaseContext, Context } from '../index.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/platforms/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/platforms/index.ts"],"names":[],"mappings":"AACA,YAAY,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC"}

package/dist/platforms/index.js

@@ -0,0 +1,2 @@
+export {};
+// Future: utility types for platform implementations can go here

package/dist/platforms/supabase.d.ts

@@ -0,0 +1,23 @@
+import type { Sql } from 'postgres';
+import type { SupabaseClient } from '@supabase/supabase-js';
+import { Flow as CoreFlow, type AnyInput, type AnySteps, type AnyDeps, EmptySteps, EmptyDeps, type Env } from '../index.js';
+export interface SupabaseResources extends Record<string, unknown> {
+    sql: Sql;
+    /**
+     * Supabase client with service role key for full database access
+     */
+    supabase: SupabaseClient;
+}
+export interface SupabaseEnv extends Env {
+    SUPABASE_DB_URL: string;
+    SUPABASE_URL: string;
+    SUPABASE_ANON_KEY: string;
+    SUPABASE_SERVICE_ROLE_KEY: string;
+    SB_EXECUTION_ID: string;
+    EDGE_WORKER_DB_URL?: string;
+    EDGE_WORKER_LOG_LEVEL?: string;
+}
+export type SupabasePlatformContext = SupabaseResources;
+export declare class Flow<I extends AnyInput = AnyInput, CustomCtx extends Record<string, unknown> = {}, S extends AnySteps = EmptySteps, D extends AnyDeps = EmptyDeps, TEnv extends Env = SupabaseEnv> extends CoreFlow<I, SupabasePlatformContext & CustomCtx, S, D, TEnv> {
+}
+//# sourceMappingURL=supabase.d.ts.map

package/dist/platforms/supabase.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"supabase.d.ts","sourceRoot":"","sources":["../../src/platforms/supabase.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AACpC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,EACL,IAAI,IAAI,QAAQ,EAChB,KAAK,QAAQ,EAAE,KAAK,QAAQ,EAAE,KAAK,OAAO,EAC1C,UAAU,EAAE,SAAS,EAAE,KAAK,GAAG,EAChC,MAAM,aAAa,CAAC;AAGrB,MAAM,WAAW,iBAAkB,SAAQ,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAChE,GAAG,EAAc,GAAG,CAAC;IACrB;;OAEG;IACH,QAAQ,EAAS,cAAc,CAAC;CACjC;AAGD,MAAM,WAAW,WAAY,SAAQ,GAAG;IACtC,eAAe,EAAY,MAAM,CAAC;IAClC,YAAY,EAAe,MAAM,CAAC;IAClC,iBAAiB,EAAU,MAAM,CAAC;IAClC,yBAAyB,EAAE,MAAM,CAAC;IAClC,eAAe,EAAY,MAAM,CAAC;IAClC,kBAAkB,CAAC,EAAQ,MAAM,CAAC;IAClC,qBAAqB,CAAC,EAAK,MAAM,CAAC;CACnC;AAMD,MAAM,MAAM,uBAAuB,GAAG,iBAAiB,CAAC;AAGxD,qBAAa,IAAI,CACf,CAAC,SAAS,QAAQ,GAAG,QAAQ,EAE7B,SAAS,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,EAAE,EAC9C,CAAC,SAAS,QAAQ,GAAG,UAAU,EAC/B,CAAC,SAAS,OAAO,GAAK,SAAS,EAC/B,IAAI,SAAS,GAAG,GAAG,WAAW,CAC9B,SAAQ,QAAQ,CAChB,CAAC,EACD,uBAAuB,GAAG,SAAS,EACnC,CAAC,EAAE,CAAC,EACJ,IAAI,CACL;CAAG"}

package/dist/platforms/supabase.js

@@ -0,0 +1,4 @@
+import { Flow as CoreFlow } from '../index.js';
+/* ---------- 4. pre-wired Flow helper -------------------------------- */
+export class Flow extends CoreFlow {
+}

package/dist/supabase.d.ts

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

package/dist/supabase.d.ts.map

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

package/dist/supabase.js

@@ -0,0 +1,2 @@
+// Re-export everything from platforms/supabase
+export * from './platforms/supabase.js';

package/dist/tsconfig.lib.tsbuildinfo

@@ -0,0 +1 @@
+{"version":"5.8.3"}

package/dist/utils.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Validates a slug string according to the following rules:
+ * - Cannot start with a number
+ * - Cannot start with an underscore
+ * - Cannot contain spaces
+ * - Cannot contain special characters like /, :, ?, #
+ * - Cannot be longer than 128 characters
+ *
+ * @param slug The slug string to validate
+ * @throws Error if the slug is invalid
+ */
+export declare function validateSlug(slug: string): void;
+/**
+ * Options for validating runtime options
+ */
+export interface ValidateRuntimeOptionsOpts {
+    optional?: boolean;
+}
+/**
+ * Validates runtime options according to the following rules:
+ * - maxAttempts should be >= 1
+ * - baseDelay should be >= 1
+ * - timeout should be >= 3
+ * - startDelay should be >= 0
+ *
+ * @param options The runtime options to validate
+ * @param opts Configuration options for validation
+ * @param opts.optional If true, allows options to be null or undefined
+ * @throws Error if any runtime option is invalid
+ */
+export declare function validateRuntimeOptions(options: {
+    maxAttempts?: number;
+    baseDelay?: number;
+    timeout?: number;
+    startDelay?: number;
+}, opts?: ValidateRuntimeOptionsOpts): void;
+//# sourceMappingURL=utils.d.ts.map

package/dist/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAsB/C;AAED;;GAEG;AACH,MAAM,WAAW,0BAA0B;IACzC,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,sBAAsB,CACpC,OAAO,EAAE;IAAE,WAAW,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAAC,UAAU,CAAC,EAAE,MAAM,CAAA;CAAE,EAC5F,IAAI,GAAE,0BAAgD,GACrD,IAAI,CAiCN"}

package/dist/utils.js

@@ -0,0 +1,73 @@
+/**
+ * Validates a slug string according to the following rules:
+ * - Cannot start with a number
+ * - Cannot start with an underscore
+ * - Cannot contain spaces
+ * - Cannot contain special characters like /, :, ?, #
+ * - Cannot be longer than 128 characters
+ *
+ * @param slug The slug string to validate
+ * @throws Error if the slug is invalid
+ */
+export function validateSlug(slug) {
+    if (slug.length > 128) {
+        throw new Error(`Slug '${slug}' cannot be longer than 128 characters`);
+    }
+    if (/^\d/.test(slug)) {
+        throw new Error(`Slug '${slug}' cannot start with a number`);
+    }
+    if (/^_/.test(slug)) {
+        throw new Error(`Slug '${slug}' cannot start with an underscore`);
+    }
+    if (/\s/.test(slug)) {
+        throw new Error(`Slug '${slug}' cannot contain spaces`);
+    }
+    if (/[/:#\-?]/.test(slug)) {
+        throw new Error(`Slug '${slug}' cannot contain special characters like /, :, ?, #, -`);
+    }
+}
+/**
+ * Validates runtime options according to the following rules:
+ * - maxAttempts should be >= 1
+ * - baseDelay should be >= 1
+ * - timeout should be >= 3
+ * - startDelay should be >= 0
+ *
+ * @param options The runtime options to validate
+ * @param opts Configuration options for validation
+ * @param opts.optional If true, allows options to be null or undefined
+ * @throws Error if any runtime option is invalid
+ */
+export function validateRuntimeOptions(options, opts = { optional: false }) {
+    const { maxAttempts, baseDelay, timeout, startDelay } = options;
+    // If optional is true, skip validation for undefined/null values
+    if (maxAttempts !== undefined && maxAttempts !== null) {
+        if (maxAttempts < 1) {
+            throw new Error('maxAttempts must be greater than or equal to 1');
+        }
+    }
+    else if (!opts.optional) {
+        throw new Error('maxAttempts is required');
+    }
+    if (baseDelay !== undefined && baseDelay !== null) {
+        if (baseDelay < 1) {
+            throw new Error('baseDelay must be greater than or equal to 1');
+        }
+    }
+    else if (!opts.optional) {
+        throw new Error('baseDelay is required');
+    }
+    if (timeout !== undefined && timeout !== null) {
+        if (timeout < 3) {
+            throw new Error('timeout must be greater than or equal to 3');
+        }
+    }
+    else if (!opts.optional) {
+        throw new Error('timeout is required');
+    }
+    if (startDelay !== undefined && startDelay !== null) {
+        if (startDelay < 0) {
+            throw new Error('startDelay must be greater than or equal to 0');
+        }
+    }
+}