@camerontaylor/paseo-protocol 0.8.0-fork.1

package/dist/provider-snapshot-codec.js

@@ -0,0 +1,71 @@
+function thinkingSetKey(set) {
+    return JSON.stringify(set);
+}
+function compactModel({ provider: _provider, thinkingOptions, defaultThinkingOptionId, ...modelFields }, thinkingSets, thinkingSetIndexes) {
+    const compact = modelFields;
+    if (thinkingOptions === undefined) {
+        if (defaultThinkingOptionId !== undefined) {
+            compact.defaultThinkingOptionId = defaultThinkingOptionId;
+        }
+        return compact;
+    }
+    const thinkingSet = {
+        options: thinkingOptions,
+        ...(defaultThinkingOptionId !== undefined ? { defaultOptionId: defaultThinkingOptionId } : {}),
+    };
+    const key = thinkingSetKey(thinkingSet);
+    const existingIndex = thinkingSetIndexes.get(key);
+    if (existingIndex !== undefined) {
+        compact.thinkingSet = existingIndex;
+        return compact;
+    }
+    const index = thinkingSets.length;
+    thinkingSets.push(thinkingSet);
+    thinkingSetIndexes.set(key, index);
+    compact.thinkingSet = index;
+    return compact;
+}
+export function compactProviderSnapshot(entries) {
+    const thinkingSets = [];
+    const thinkingSetIndexes = new Map();
+    const compactEntries = entries.map((entry) => {
+        if (entry.models === undefined) {
+            return entry;
+        }
+        return {
+            ...entry,
+            models: entry.models.map((model) => compactModel(model, thinkingSets, thinkingSetIndexes)),
+        };
+    });
+    return { entries: compactEntries, thinkingSets };
+}
+function expandModel(provider, model, thinkingSets) {
+    const { thinkingSet: thinkingSetIndex, ...modelFields } = model;
+    if (thinkingSetIndex === undefined) {
+        return { provider, ...modelFields };
+    }
+    const thinkingSet = thinkingSets[thinkingSetIndex];
+    if (!thinkingSet) {
+        throw new RangeError(`Provider snapshot references missing thinking set ${thinkingSetIndex}`);
+    }
+    return {
+        provider,
+        ...modelFields,
+        thinkingOptions: thinkingSet.options,
+        ...(thinkingSet.defaultOptionId !== undefined
+            ? { defaultThinkingOptionId: thinkingSet.defaultOptionId }
+            : {}),
+    };
+}
+export function expandProviderSnapshot(snapshot) {
+    return snapshot.entries.map((entry) => {
+        const { models, ...entryFields } = entry;
+        if (models === undefined)
+            return entryFields;
+        return {
+            ...entryFields,
+            models: models.map((model) => expandModel(entryFields.provider, model, snapshot.thinkingSets)),
+        };
+    });
+}
+//# sourceMappingURL=provider-snapshot-codec.js.map

package/dist/schedule/cadence.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Convert an exact rolling interval to an equivalent five-field cron cadence.
+ * Returns null when cron's calendar boundaries would change the interval.
+ */
+export declare function everyMsToFiveFieldCron(everyMs: number): string | null;
+//# sourceMappingURL=cadence.d.ts.map

package/dist/schedule/cadence.js

@@ -0,0 +1,28 @@
+/**
+ * Convert an exact rolling interval to an equivalent five-field cron cadence.
+ * Returns null when cron's calendar boundaries would change the interval.
+ */
+export function everyMsToFiveFieldCron(everyMs) {
+    const minutes = everyMs / 60000;
+    if (!Number.isInteger(minutes) || minutes <= 0) {
+        return null;
+    }
+    if (minutes < 60 && 60 % minutes === 0) {
+        return `*/${minutes} * * * *`;
+    }
+    if (minutes === 60) {
+        return "0 * * * *";
+    }
+    if (minutes % 60 !== 0) {
+        return null;
+    }
+    const hours = minutes / 60;
+    if (hours < 24 && 24 % hours === 0) {
+        return `0 */${hours} * * *`;
+    }
+    if (hours === 24) {
+        return "0 0 * * *";
+    }
+    return null;
+}
+//# sourceMappingURL=cadence.js.map

package/dist/schedule/cron-expression.d.ts

@@ -0,0 +1,13 @@
+export interface CronFieldMatcher {
+    matches(value: number): boolean;
+}
+export interface ParsedCronExpression {
+    minute: CronFieldMatcher;
+    hour: CronFieldMatcher;
+    dayOfMonth: CronFieldMatcher;
+    month: CronFieldMatcher;
+    dayOfWeek: CronFieldMatcher;
+}
+export declare function parseCronExpression(expression: string): ParsedCronExpression;
+export declare function validateCronExpression(expression: string): string | null;
+//# sourceMappingURL=cron-expression.d.ts.map

package/dist/schedule/cron-expression.js

@@ -0,0 +1,97 @@
+const CRON_FIELD_BOUNDS = [
+    { min: 0, max: 59, name: "minute" },
+    { min: 0, max: 23, name: "hour" },
+    { min: 1, max: 31, name: "day-of-month" },
+    { min: 1, max: 12, name: "month" },
+    { min: 0, max: 6, name: "day-of-week" },
+];
+function createRange(start, end, step) {
+    const values = [];
+    for (let value = start; value <= end; value += step) {
+        values.push(value);
+    }
+    return values;
+}
+function parseStepPart(part, bounds) {
+    const stepParts = part.split("/");
+    if (stepParts.length > 2) {
+        throw new Error(`Invalid cron ${bounds.name} step`);
+    }
+    const [base, stepSource] = stepParts;
+    const normalizedStep = stepSource?.trim();
+    const step = normalizedStep === undefined ? 1 : Number.parseInt(normalizedStep, 10);
+    if (!Number.isInteger(step) ||
+        step <= 0 ||
+        (normalizedStep !== undefined && String(step) !== normalizedStep)) {
+        throw new Error(`Invalid cron ${bounds.name} step`);
+    }
+    return { base, step };
+}
+function parseField(source, bounds) {
+    const trimmed = source.trim();
+    if (!trimmed) {
+        throw new Error(`Invalid cron ${bounds.name} field`);
+    }
+    const allowed = new Set();
+    for (const rawPart of trimmed.split(",")) {
+        const part = rawPart.trim();
+        if (!part) {
+            throw new Error(`Invalid cron ${bounds.name} field`);
+        }
+        const { base, step } = parseStepPart(part, bounds);
+        if (base === "*") {
+            for (const value of createRange(bounds.min, bounds.max, step)) {
+                allowed.add(value);
+            }
+            continue;
+        }
+        const rangeMatch = base.match(/^(\d+)-(\d+)$/);
+        if (rangeMatch) {
+            const start = Number.parseInt(rangeMatch[1], 10);
+            const end = Number.parseInt(rangeMatch[2], 10);
+            if (start > end || start < bounds.min || end > bounds.max) {
+                throw new Error(`Invalid cron ${bounds.name} range`);
+            }
+            for (const value of createRange(start, end, step)) {
+                allowed.add(value);
+            }
+            continue;
+        }
+        if (!/^\d+$/.test(base)) {
+            throw new Error(`Invalid cron ${bounds.name} value`);
+        }
+        const value = Number.parseInt(base, 10);
+        if (!Number.isInteger(value) || value < bounds.min || value > bounds.max) {
+            throw new Error(`Invalid cron ${bounds.name} value`);
+        }
+        allowed.add(value);
+    }
+    return {
+        matches(value) {
+            return allowed.has(value);
+        },
+    };
+}
+export function parseCronExpression(expression) {
+    const parts = expression.trim().split(/\s+/);
+    if (parts.length !== 5) {
+        throw new Error("Cron expressions must have 5 fields");
+    }
+    return {
+        minute: parseField(parts[0], CRON_FIELD_BOUNDS[0]),
+        hour: parseField(parts[1], CRON_FIELD_BOUNDS[1]),
+        dayOfMonth: parseField(parts[2], CRON_FIELD_BOUNDS[2]),
+        month: parseField(parts[3], CRON_FIELD_BOUNDS[3]),
+        dayOfWeek: parseField(parts[4], CRON_FIELD_BOUNDS[4]),
+    };
+}
+export function validateCronExpression(expression) {
+    try {
+        parseCronExpression(expression);
+        return null;
+    }
+    catch (error) {
+        return error instanceof Error ? error.message : "Invalid cron expression";
+    }
+}
+//# sourceMappingURL=cron-expression.js.map