@a5c-ai/genty-platform 5.1.1-staging.0007199a1cb2

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAIH,sEAAsE;AACtE,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAOjD,YAAY,EACV,YAAY,EACZ,iBAAiB,GAClB,MAAM,wBAAwB,CAAC;AAGhC,YAAY,EACV,YAAY,EACZ,eAAe,EACf,kBAAkB,EAClB,yBAAyB,EACzB,2BAA2B,EAC3B,cAAc,EACd,WAAW,EACX,gBAAgB,EAChB,eAAe,EACf,YAAY,EACZ,yBAAyB,EACzB,kBAAkB,EAClB,qBAAqB,EACrB,oBAAoB,EACpB,oBAAoB,GACrB,MAAM,wBAAwB,CAAC;AAGhC,YAAY,EACV,aAAa,EACb,iBAAiB,GAClB,MAAM,wBAAwB,CAAC;AAGhC,YAAY,EAAE,sBAAsB,EAAE,MAAM,wBAAwB,CAAC;AAIrE,8DAA8D;AAC9D,MAAM,WAAW,WAAW;IAC1B,WAAW,IAAI,KAAK,CAAC;QACnB,QAAQ,EAAE,MAAM,CAAC;QACjB,MAAM,EAAE,MAAM,CAAC;QACf,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,YAAY,CAAC,EAAE,MAAM,CAAC;QACtB,wBAAwB,CAAC,EAAE,MAAM,CAAC;QAClC,oBAAoB,CAAC,EAAE,MAAM,CAAC;QAC9B,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,SAAS,CAAC,EAAE,MAAM,CAAC;KACpB,CAAC,CAAC;CACJ;AAID;;GAEG;AACH,MAAM,MAAM,eAAe,GACvB,eAAe,GACf,UAAU,GACV,cAAc,GACd,cAAc,GACd,SAAS,CAAC;AAEd;;GAEG;AACH,MAAM,MAAM,cAAc,GACtB,MAAM,GACN,OAAO,GACP,SAAS,GACT,SAAS,GACT,SAAS,GACT,MAAM,CAAC;AAEX;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,gBAAgB,EAAE,OAAO,CAAC;IAC1B,+BAA+B,EAAE,MAAM,CAAC;IACxC,mBAAmB,EAAE,OAAO,CAAC;IAC7B,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB,qBAAqB,CAAC,EAAE,MAAM,CAAC;CAChC;AAED,qCAAqC;AACrC,MAAM,WAAW,cAAc;IAC7B,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,cAAc,GAAG,oBAAoB,CAAC;IAC9C,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,kBAAkB;IACjC,WAAW,EAAE,OAAO,CAAC;IACrB,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,iBAAiB,CAAC,EAAE,cAAc,CAAC;CACpC;AAGD,YAAY,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAK/D,YAAY,EACV,iBAAiB,EACjB,sBAAsB,GACvB,MAAM,wBAAwB,CAAC;AAOhC,YAAY,EACV,cAAc,EACd,iBAAiB,EACjB,YAAY,EACZ,eAAe,EACf,UAAU,EACV,kBAAkB,EAClB,uBAAuB,EACvB,cAAc,EACd,iBAAiB,EACjB,YAAY,GACb,MAAM,wBAAwB,CAAC"}

package/dist/types.js

@@ -0,0 +1,21 @@
+"use strict";
+/**
+ * Shared type definitions for the genty platform.
+ *
+ * Types fall into two categories:
+ * 1. Locally-defined types that genty owns (governance, breakpoints, interaction).
+ * 2. Re-exported SDK types for values returned by SDK functions. These re-exports
+ *    centralise the SDK type dependency so consumer files import from here
+ *    instead of scattering @a5c-ai/babysitter-sdk imports throughout the tree.
+ *
+ * When the SDK coupling is fully removed (phase 6+), category-2 types will be
+ * replaced with locally-defined equivalents or mapped to orchestration
+ * provider interface types (see orchestration/interfaces.ts).
+ *
+ * Migration mapping (category-2 -> orchestration interfaces):
+ *   JournalEvent      -> orchestration/interfaces.ts RunEvent
+ *   EffectAction       -> orchestration/interfaces.ts PendingEffect
+ *   IterationResult    -> orchestration/interfaces.ts IterationResult
+ *   CreateRunOptions   -> orchestration/interfaces.ts CreateRunOptions
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/atomic.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Atomic file write utility.
+ *
+ * Writes data to a temporary file in the same directory and then renames
+ * it to the target path, ensuring the target is either fully written or
+ * unchanged. Retries on transient EPERM / EACCES errors (Windows).
+ */
+/**
+ * Write `data` to `targetPath` atomically using tmp-file + rename.
+ *
+ * @param targetPath - Destination file path.
+ * @param data       - Content to write (string or Buffer).
+ * @param retries    - Number of rename retries on transient errors (default 3).
+ */
+export declare function writeFileAtomic(targetPath: string, data: string | Buffer, retries?: number): Promise<void>;
+//# sourceMappingURL=atomic.d.ts.map

package/dist/utils/atomic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"atomic.d.ts","sourceRoot":"","sources":["../../src/utils/atomic.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAMH;;;;;;GAMG;AACH,wBAAsB,eAAe,CACnC,UAAU,EAAE,MAAM,EAClB,IAAI,EAAE,MAAM,GAAG,MAAM,EACrB,OAAO,SAAI,GACV,OAAO,CAAC,IAAI,CAAC,CAsBf"}

package/dist/utils/atomic.js

@@ -0,0 +1,75 @@
+"use strict";
+/**
+ * Atomic file write utility.
+ *
+ * Writes data to a temporary file in the same directory and then renames
+ * it to the target path, ensuring the target is either fully written or
+ * unchanged. Retries on transient EPERM / EACCES errors (Windows).
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeFileAtomic = writeFileAtomic;
+const node_fs_1 = require("node:fs");
+const path = __importStar(require("node:path"));
+const crypto = __importStar(require("node:crypto"));
+/**
+ * Write `data` to `targetPath` atomically using tmp-file + rename.
+ *
+ * @param targetPath - Destination file path.
+ * @param data       - Content to write (string or Buffer).
+ * @param retries    - Number of rename retries on transient errors (default 3).
+ */
+async function writeFileAtomic(targetPath, data, retries = 3) {
+    const dir = path.dirname(targetPath);
+    const tmpName = `.${path.basename(targetPath)}.${crypto.randomBytes(6).toString("hex")}.tmp`;
+    const tmpPath = path.join(dir, tmpName);
+    await node_fs_1.promises.writeFile(tmpPath, data);
+    for (let attempt = 0; attempt <= retries; attempt++) {
+        try {
+            await node_fs_1.promises.rename(tmpPath, targetPath);
+            return;
+        }
+        catch (err) {
+            const code = err.code;
+            if ((code === "EPERM" || code === "EACCES") && attempt < retries) {
+                await new Promise((r) => setTimeout(r, 50 * (attempt + 1)));
+                continue;
+            }
+            // Clean up temp file on final failure
+            await node_fs_1.promises.unlink(tmpPath).catch(() => { });
+            throw err;
+        }
+    }
+}

package/dist/utils/concurrency.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Effective concurrency calculation for effect dispatch groups.
+ *
+ * Ported from @a5c-ai/babysitter-sdk/tasks/grouping for local use so that
+ * the platform does not need a runtime SDK import for this pure function.
+ */
+interface ConcurrencyAction {
+    schedulerHints?: {
+        pendingCount?: number;
+    };
+}
+interface EffectiveConcurrencyOptions {
+    maxConcurrency?: number;
+}
+/**
+ * Determine the effective concurrency for a group of effect actions.
+ *
+ * Considers:
+ *   - An explicit maxConcurrency option
+ *   - The minimum pendingCount from any action's schedulerHints (if any have it)
+ *   - The number of actions (default upper bound)
+ *
+ * Returns at least 0 for empty arrays, at least 1 otherwise.
+ */
+export declare function getEffectiveConcurrency(actions: ConcurrencyAction[], options?: EffectiveConcurrencyOptions): number;
+export {};
+//# sourceMappingURL=concurrency.d.ts.map

package/dist/utils/concurrency.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"concurrency.d.ts","sourceRoot":"","sources":["../../src/utils/concurrency.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,UAAU,iBAAiB;IACzB,cAAc,CAAC,EAAE;QACf,YAAY,CAAC,EAAE,MAAM,CAAC;KACvB,CAAC;CACH;AAED,UAAU,2BAA2B;IACnC,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED;;;;;;;;;GASG;AACH,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,iBAAiB,EAAE,EAC5B,OAAO,CAAC,EAAE,2BAA2B,GACpC,MAAM,CA4BR"}

package/dist/utils/concurrency.js

@@ -0,0 +1,42 @@
+"use strict";
+/**
+ * Effective concurrency calculation for effect dispatch groups.
+ *
+ * Ported from @a5c-ai/babysitter-sdk/tasks/grouping for local use so that
+ * the platform does not need a runtime SDK import for this pure function.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEffectiveConcurrency = getEffectiveConcurrency;
+/**
+ * Determine the effective concurrency for a group of effect actions.
+ *
+ * Considers:
+ *   - An explicit maxConcurrency option
+ *   - The minimum pendingCount from any action's schedulerHints (if any have it)
+ *   - The number of actions (default upper bound)
+ *
+ * Returns at least 0 for empty arrays, at least 1 otherwise.
+ */
+function getEffectiveConcurrency(actions, options) {
+    if (actions.length === 0) {
+        return 0;
+    }
+    const candidates = [actions.length];
+    if (options?.maxConcurrency !== undefined) {
+        candidates.push(options.maxConcurrency);
+    }
+    // Check per-action pendingCount hints as concurrency bounds
+    for (const action of actions) {
+        const pendingCount = action.schedulerHints?.pendingCount;
+        if (typeof pendingCount === "number") {
+            candidates.push(pendingCount);
+        }
+    }
+    // If we have explicit hints (maxConcurrency or pendingCount), use only those
+    // (don't bound by actions.length). Otherwise fall back to actions.length.
+    const explicitCandidates = candidates.slice(1); // everything except actions.length
+    const effective = explicitCandidates.length > 0
+        ? Math.min(...explicitCandidates)
+        : actions.length;
+    return Math.max(effective, 1);
+}

package/dist/utils/defaults.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Local orchestration defaults.
+ *
+ * These constants were previously imported from @a5c-ai/babysitter-sdk DEFAULTS.
+ * Defined locally so the platform does not need a runtime SDK import for them.
+ */
+export declare const ORCHESTRATION_DEFAULTS: {
+    /** Maximum iterations for a single orchestration run. */
+    readonly maxIterations: 65000;
+};
+//# sourceMappingURL=defaults.d.ts.map

package/dist/utils/defaults.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"defaults.d.ts","sourceRoot":"","sources":["../../src/utils/defaults.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,eAAO,MAAM,sBAAsB;IACjC,yDAAyD;;CAEjD,CAAC"}

package/dist/utils/defaults.js

@@ -0,0 +1,13 @@
+"use strict";
+/**
+ * Local orchestration defaults.
+ *
+ * These constants were previously imported from @a5c-ai/babysitter-sdk DEFAULTS.
+ * Defined locally so the platform does not need a runtime SDK import for them.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ORCHESTRATION_DEFAULTS = void 0;
+exports.ORCHESTRATION_DEFAULTS = {
+    /** Maximum iterations for a single orchestration run. */
+    maxIterations: 65_000,
+};

package/dist/utils/errors.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Genty platform error types.
+ *
+ * These mirror the BabysitterRuntimeError / ErrorCategory from babysitter-sdk,
+ * re-exported under genty-native names so the platform package can avoid
+ * importing directly from the SDK.
+ */
+export declare enum ErrorCategory {
+    Configuration = "CONFIGURATION",
+    Validation = "VALIDATION",
+    Runtime = "RUNTIME",
+    External = "EXTERNAL",
+    Internal = "INTERNAL"
+}
+export declare const ERROR_CATEGORY_DESCRIPTIONS: Record<ErrorCategory, string>;
+export interface GentyErrorDetails {
+    [key: string]: unknown;
+}
+export interface GentyErrorOptions {
+    category?: ErrorCategory;
+    suggestions?: string[];
+    nextSteps?: string[];
+    details?: GentyErrorDetails;
+    cause?: Error;
+}
+/**
+ * Base runtime error for the genty platform.
+ *
+ * API-compatible with BabysitterRuntimeError so existing catch blocks
+ * and error-inspection code continue to work without changes.
+ */
+export declare class GentyRuntimeError extends Error {
+    readonly details?: GentyErrorDetails;
+    readonly category: ErrorCategory;
+    readonly suggestions: string[];
+    readonly nextSteps: string[];
+    constructor(name: string, message: string, options?: GentyErrorOptions | GentyErrorDetails);
+}
+/**
+ * Backward-compatible alias.
+ * Existing code that references BabysitterRuntimeError will keep compiling.
+ */
+export { GentyRuntimeError as BabysitterRuntimeError };
+/**
+ * Type guard for GentyRuntimeError instances.
+ */
+export declare function isGentyError(err: unknown): err is GentyRuntimeError;
+/** @deprecated Use isGentyError instead */
+export { isGentyError as isBabysitterError };
+//# sourceMappingURL=errors.d.ts.map

package/dist/utils/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/utils/errors.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAIH,oBAAY,aAAa;IACvB,aAAa,kBAAkB;IAC/B,UAAU,eAAe;IACzB,OAAO,YAAY;IACnB,QAAQ,aAAa;IACrB,QAAQ,aAAa;CACtB;AAED,eAAO,MAAM,2BAA2B,EAAE,MAAM,CAAC,aAAa,EAAE,MAAM,CAMrE,CAAC;AAIF,MAAM,WAAW,iBAAiB;IAChC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAED,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,EAAE,aAAa,CAAC;IACzB,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;IACvB,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB,OAAO,CAAC,EAAE,iBAAiB,CAAC;IAC5B,KAAK,CAAC,EAAE,KAAK,CAAC;CACf;AAWD;;;;;GAKG;AACH,qBAAa,iBAAkB,SAAQ,KAAK;IAC1C,QAAQ,CAAC,OAAO,CAAC,EAAE,iBAAiB,CAAC;IACrC,QAAQ,CAAC,QAAQ,EAAE,aAAa,CAAC;IACjC,QAAQ,CAAC,WAAW,EAAE,MAAM,EAAE,CAAC;IAC/B,QAAQ,CAAC,SAAS,EAAE,MAAM,EAAE,CAAC;gBAEjB,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,iBAAiB,GAAG,iBAAiB;CAmB3F;AAED;;;GAGG;AACH,OAAO,EAAE,iBAAiB,IAAI,sBAAsB,EAAE,CAAC;AAEvD;;GAEG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,OAAO,GAAG,GAAG,IAAI,iBAAiB,CAEnE;AAED,2CAA2C;AAC3C,OAAO,EAAE,YAAY,IAAI,iBAAiB,EAAE,CAAC"}

package/dist/utils/errors.js

@@ -0,0 +1,76 @@
+"use strict";
+/**
+ * Genty platform error types.
+ *
+ * These mirror the BabysitterRuntimeError / ErrorCategory from babysitter-sdk,
+ * re-exported under genty-native names so the platform package can avoid
+ * importing directly from the SDK.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BabysitterRuntimeError = exports.GentyRuntimeError = exports.ERROR_CATEGORY_DESCRIPTIONS = exports.ErrorCategory = void 0;
+exports.isGentyError = isGentyError;
+exports.isBabysitterError = isGentyError;
+// ── Error Categories ──────────────────────────────────────────────────────
+var ErrorCategory;
+(function (ErrorCategory) {
+    ErrorCategory["Configuration"] = "CONFIGURATION";
+    ErrorCategory["Validation"] = "VALIDATION";
+    ErrorCategory["Runtime"] = "RUNTIME";
+    ErrorCategory["External"] = "EXTERNAL";
+    ErrorCategory["Internal"] = "INTERNAL";
+})(ErrorCategory || (exports.ErrorCategory = ErrorCategory = {}));
+exports.ERROR_CATEGORY_DESCRIPTIONS = {
+    [ErrorCategory.Configuration]: "Configuration or setup issue",
+    [ErrorCategory.Validation]: "Input validation failure",
+    [ErrorCategory.Runtime]: "Runtime execution error",
+    [ErrorCategory.External]: "External service or dependency failure",
+    [ErrorCategory.Internal]: "Internal error (please report as a bug)",
+};
+// ── Core Error Class ──────────────────────────────────────────────────────
+function isErrorOptions(obj) {
+    if (!obj || typeof obj !== "object")
+        return false;
+    const keys = Object.keys(obj);
+    const optionKeys = ["category", "suggestions", "nextSteps", "details", "cause"];
+    return keys.some((k) => optionKeys.includes(k));
+}
+/**
+ * Base runtime error for the genty platform.
+ *
+ * API-compatible with BabysitterRuntimeError so existing catch blocks
+ * and error-inspection code continue to work without changes.
+ */
+class GentyRuntimeError extends Error {
+    details;
+    category;
+    suggestions;
+    nextSteps;
+    constructor(name, message, options) {
+        super(message);
+        this.name = name;
+        if (options && !isErrorOptions(options)) {
+            this.details = options;
+            this.category = ErrorCategory.Runtime;
+            this.suggestions = [];
+            this.nextSteps = [];
+        }
+        else {
+            const opts = options;
+            this.details = opts?.details;
+            this.category = opts?.category ?? ErrorCategory.Runtime;
+            this.suggestions = opts?.suggestions ?? [];
+            this.nextSteps = opts?.nextSteps ?? [];
+            if (opts?.cause) {
+                this.cause = opts.cause;
+            }
+        }
+    }
+}
+exports.GentyRuntimeError = GentyRuntimeError;
+exports.BabysitterRuntimeError = GentyRuntimeError;
+/**
+ * Type guard for GentyRuntimeError instances.
+ */
+function isGentyError(err) {
+    return err instanceof GentyRuntimeError;
+}

package/dist/utils/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Platform utility barrel.
+ */
+export { GentyRuntimeError, BabysitterRuntimeError, ErrorCategory, ERROR_CATEGORY_DESCRIPTIONS, isGentyError, isBabysitterError, type GentyErrorDetails, type GentyErrorOptions, } from "./errors";
+export { writeFileAtomic } from "./atomic";
+export { parsePattern, matchPattern, type BreakpointPattern, type AttributePredicate, type PredicateOp, } from "./patterns";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EACL,iBAAiB,EACjB,sBAAsB,EACtB,aAAa,EACb,2BAA2B,EAC3B,YAAY,EACZ,iBAAiB,EACjB,KAAK,iBAAiB,EACtB,KAAK,iBAAiB,GACvB,MAAM,UAAU,CAAC;AAElB,OAAO,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAE3C,OAAO,EACL,YAAY,EACZ,YAAY,EACZ,KAAK,iBAAiB,EACtB,KAAK,kBAAkB,EACvB,KAAK,WAAW,GACjB,MAAM,YAAY,CAAC"}

package/dist/utils/index.js

@@ -0,0 +1,18 @@
+"use strict";
+/**
+ * Platform utility barrel.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.matchPattern = exports.parsePattern = exports.writeFileAtomic = exports.isBabysitterError = exports.isGentyError = exports.ERROR_CATEGORY_DESCRIPTIONS = exports.ErrorCategory = exports.BabysitterRuntimeError = exports.GentyRuntimeError = void 0;
+var errors_1 = require("./errors");
+Object.defineProperty(exports, "GentyRuntimeError", { enumerable: true, get: function () { return errors_1.GentyRuntimeError; } });
+Object.defineProperty(exports, "BabysitterRuntimeError", { enumerable: true, get: function () { return errors_1.BabysitterRuntimeError; } });
+Object.defineProperty(exports, "ErrorCategory", { enumerable: true, get: function () { return errors_1.ErrorCategory; } });
+Object.defineProperty(exports, "ERROR_CATEGORY_DESCRIPTIONS", { enumerable: true, get: function () { return errors_1.ERROR_CATEGORY_DESCRIPTIONS; } });
+Object.defineProperty(exports, "isGentyError", { enumerable: true, get: function () { return errors_1.isGentyError; } });
+Object.defineProperty(exports, "isBabysitterError", { enumerable: true, get: function () { return errors_1.isBabysitterError; } });
+var atomic_1 = require("./atomic");
+Object.defineProperty(exports, "writeFileAtomic", { enumerable: true, get: function () { return atomic_1.writeFileAtomic; } });
+var patterns_1 = require("./patterns");
+Object.defineProperty(exports, "parsePattern", { enumerable: true, get: function () { return patterns_1.parsePattern; } });
+Object.defineProperty(exports, "matchPattern", { enumerable: true, get: function () { return patterns_1.matchPattern; } });

package/dist/utils/patterns.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Pattern parsing and matching for breakpoint auto-approval rules.
+ *
+ * Ported from @a5c-ai/babysitter-sdk/breakpoints/patterns for local use.
+ *
+ * Pattern syntax:
+ *   <id-glob>                          - e.g., "confirm.*"
+ *   <id-glob>(<predicate> [AND ...])   - e.g., "*.review(tags contains 'design')"
+ *
+ * Id-glob supports * as a wildcard matching any segment(s).
+ * Attribute predicates: "tags contains '<value>'" or "expert = '<value>'"
+ * Multiple predicates joined with AND.
+ */
+export type PredicateOp = "contains" | "=";
+export interface AttributePredicate {
+    attr: string;
+    op: PredicateOp;
+    value: string;
+}
+export interface BreakpointPattern {
+    idGlob: string;
+    predicates: AttributePredicate[];
+}
+/**
+ * Parse a pattern string into a structured BreakpointPattern.
+ */
+export declare function parsePattern(raw: string): BreakpointPattern;
+/**
+ * Match a breakpointId and attributes against a parsed pattern.
+ */
+export declare function matchPattern(pattern: BreakpointPattern, breakpointId: string, attributes: {
+    tags?: string[];
+    expert?: string;
+}): boolean;
+//# sourceMappingURL=patterns.d.ts.map

package/dist/utils/patterns.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"patterns.d.ts","sourceRoot":"","sources":["../../src/utils/patterns.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAIH,MAAM,MAAM,WAAW,GAAG,UAAU,GAAG,GAAG,CAAC;AAE3C,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,WAAW,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,iBAAiB;IAChC,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,kBAAkB,EAAE,CAAC;CAClC;AAID;;GAEG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,iBAAiB,CAsB3D;AAwBD;;GAEG;AACH,wBAAgB,YAAY,CAC1B,OAAO,EAAE,iBAAiB,EAC1B,YAAY,EAAE,MAAM,EACpB,UAAU,EAAE;IAAE,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,GAC/C,OAAO,CAUT"}

package/dist/utils/patterns.js

@@ -0,0 +1,84 @@
+"use strict";
+/**
+ * Pattern parsing and matching for breakpoint auto-approval rules.
+ *
+ * Ported from @a5c-ai/babysitter-sdk/breakpoints/patterns for local use.
+ *
+ * Pattern syntax:
+ *   <id-glob>                          - e.g., "confirm.*"
+ *   <id-glob>(<predicate> [AND ...])   - e.g., "*.review(tags contains 'design')"
+ *
+ * Id-glob supports * as a wildcard matching any segment(s).
+ * Attribute predicates: "tags contains '<value>'" or "expert = '<value>'"
+ * Multiple predicates joined with AND.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parsePattern = parsePattern;
+exports.matchPattern = matchPattern;
+// ── Parsing ───────────────────────────────────────────────────────────────
+/**
+ * Parse a pattern string into a structured BreakpointPattern.
+ */
+function parsePattern(raw) {
+    const trimmed = raw.trim();
+    const parenOpen = trimmed.indexOf("(");
+    if (parenOpen === -1) {
+        return { idGlob: trimmed, predicates: [] };
+    }
+    const parenClose = trimmed.lastIndexOf(")");
+    if (parenClose === -1 || parenClose <= parenOpen) {
+        throw new Error(`Invalid pattern: unmatched parenthesis in "${raw}"`);
+    }
+    const idGlob = trimmed.slice(0, parenOpen).trim();
+    const predicateStr = trimmed.slice(parenOpen + 1, parenClose).trim();
+    if (!predicateStr) {
+        return { idGlob, predicates: [] };
+    }
+    const predicates = parsePredicates(predicateStr);
+    return { idGlob, predicates };
+}
+function parsePredicates(str) {
+    const parts = str.split(/\s+AND\s+/i);
+    return parts.map(parseSinglePredicate);
+}
+function parseSinglePredicate(str) {
+    const trimmed = str.trim();
+    const match = trimmed.match(/^(\w+)\s+(contains|=)\s+'([^']*)'$/);
+    if (!match) {
+        throw new Error(`Invalid predicate: "${trimmed}". Expected: attr contains 'value' or attr = 'value'`);
+    }
+    return {
+        attr: match[1],
+        op: match[2],
+        value: match[3],
+    };
+}
+// ── Matching ──────────────────────────────────────────────────────────────
+/**
+ * Match a breakpointId and attributes against a parsed pattern.
+ */
+function matchPattern(pattern, breakpointId, attributes) {
+    if (!matchGlob(pattern.idGlob, breakpointId)) {
+        return false;
+    }
+    for (const pred of pattern.predicates) {
+        if (!matchPredicate(pred, attributes)) {
+            return false;
+        }
+    }
+    return true;
+}
+function matchGlob(glob, value) {
+    const escaped = glob.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
+    const regexStr = "^" + escaped.replace(/\*/g, ".*") + "$";
+    return new RegExp(regexStr).test(value);
+}
+function matchPredicate(pred, attributes) {
+    if (pred.attr === "tags" && pred.op === "contains") {
+        return Array.isArray(attributes.tags) && attributes.tags.includes(pred.value);
+    }
+    if (pred.attr === "expert" && pred.op === "=") {
+        return attributes.expert === pred.value;
+    }
+    return false;
+}