@danceiny/gotry 0.0.1-rc.21 → 0.0.1-rc.24

package/dist/scripts/booking-copilot-dsh-plugin-proof-tests.js

@@ -1,39 +1,36 @@
+/** Closed dsh capability-tool registration proof (no dsh runtime required). */
 import assert from 'node:assert/strict';
 import { Ajv2020 } from 'ajv/dist/2020.js';
+// @ts-expect-error Runtime dsh plugins are JavaScript modules registered by path.
 import { apply, embeddedBookingToolDefinitions } from '../src/booking-surface/dsh-plugin.js';
 const registered = [];
 apply({
     tools: {
-        register (tool) {
-            registered.push(tool);
-        }
-    }
+        register(tool) { registered.push(tool); },
+    },
 });
 assert.equal(registered.length, 6);
-assert.deepEqual(registered.map((tool)=>tool.name), [
+assert.deepEqual(registered.map((tool) => tool.name), [
     'booking_search_hotels',
     'booking_refine_results',
     'booking_find_room_offers',
     'booking_compare_offers',
     'booking_prepare_booking',
-    'booking_observe_booking'
+    'booking_observe_booking',
 ]);
 assert.deepEqual(registered, embeddedBookingToolDefinitions);
-assert.ok(!registered.some((tool)=>/gotry_book|trade|payment/i.test(String(tool.name))));
-assert.ok(registered.every((tool)=>{
+assert.ok(!registered.some((tool) => /gotry_book|trade|payment/i.test(String(tool.name))));
+assert.ok(registered.every((tool) => {
     const parameters = tool.parameters;
     return parameters.additionalProperties === false && Object.keys(parameters.properties ?? {}).join(',') === 'decision';
 }), 'every model-facing tool accepts only one typed decision envelope');
-const prepare = registered.find((tool)=>tool.name === 'booking_prepare_booking');
+const prepare = registered.find((tool) => tool.name === 'booking_prepare_booking');
 const prepareParameters = prepare.parameters;
 const operationBranches = prepareParameters.properties.decision.oneOf[0]?.properties?.action?.oneOf ?? [];
 assert.equal(operationBranches.length, 2, 'prepare-booking exposes offer.check + checkout.prepare only');
 assert.ok(!JSON.stringify(prepare.parameters).includes('book"'), 'schema has no Book discriminator');
-const search = registered.find((tool)=>tool.name === 'booking_search_hotels');
-const validateSearchTool = new Ajv2020({
-    allErrors: true,
-    strict: true
-}).compile(search.parameters);
+const search = registered.find((tool) => tool.name === 'booking_search_hotels');
+const validateSearchTool = new Ajv2020({ allErrors: true, strict: true }).compile(search.parameters);
 const validSearchDecision = {
     decision: {
         kind: 'operation',
@@ -49,51 +46,27 @@ const validSearchDecision = {
                 patch: {
                     budget: {
                         strength: 'must',
-                        value: {
-                            max: {
-                                amount: '1000',
-                                currency: 'AED',
-                                sourceFactRef: 'fact-budget-1'
-                            }
-                        }
-                    }
-                }
-            }
-        }
-    }
+                        value: { max: { amount: '1000', currency: 'AED', sourceFactRef: 'fact-budget-1' } },
+                    },
+                },
+            },
+        },
+    },
 };
 assert.equal(validateSearchTool(validSearchDecision), true, JSON.stringify(validateSearchTool.errors));
-assert.equal(validateSearchTool({
-    decision: {
-        kind: 'operation',
-        action: {
-            schemaVersion: 'booking.surface',
-            kind: 'search.run',
-            actionId: 'action-model-v2',
-            contextRef: 'ctx-model-1',
-            expectedRevision: 0,
-            reason: 'Run the authoritative workspace search.',
-            factRefs: [],
-            input: {}
-        }
-    }
-}), true, JSON.stringify(validateSearchTool.errors));
+assert.equal(validateSearchTool({ decision: { kind: 'operation', action: {
+            schemaVersion: 'booking.surface', kind: 'search.run', actionId: 'action-model-v2', contextRef: 'ctx-model-1', expectedRevision: 0,
+            reason: 'Run the authoritative workspace search.', factRefs: [], input: {},
+        } } }), true, JSON.stringify(validateSearchTool.errors));
 assert.equal(validateSearchTool({
     ...validSearchDecision,
     decision: {
         ...validSearchDecision.decision,
         action: {
             ...validSearchDecision.decision.action,
-            input: {
-                patch: {
-                    unknownCriterion: {
-                        strength: 'must',
-                        value: true
-                    }
-                }
-            }
-        }
-    }
+            input: { patch: { unknownCriterion: { strength: 'must', value: true } } },
+        },
+    },
 }), false, 'model-facing tool schema closes nested search criteria');
 assert.equal(validateSearchTool({
     ...validSearchDecision,
@@ -105,18 +78,12 @@ assert.equal(validateSearchTool({
                 patch: {
                     budget: {
                         strength: 'must',
-                        value: {
-                            max: {
-                                amount: 1000,
-                                currency: 'AED',
-                                sourceFactRef: 'fact-budget-1'
-                            }
-                        }
-                    }
-                }
-            }
-        }
-    }
+                        value: { max: { amount: 1000, currency: 'AED', sourceFactRef: 'fact-budget-1' } },
+                    },
+                },
+            },
+        },
+    },
 }), false, 'model-facing Money.amount rejects numbers');
 assert.equal(validateSearchTool({
     ...validSearchDecision,
@@ -124,17 +91,8 @@ assert.equal(validateSearchTool({
         ...validSearchDecision.decision,
         action: {
             ...validSearchDecision.decision.action,
-            input: {
-                patch: {
-                    holder: {
-                        email: 'x@example.com'
-                    }
-                }
-            }
-        }
-    }
+            input: { patch: { holder: { email: 'x@example.com' } } },
+        },
+    },
 }), false, 'model-facing tool schema rejects nested holder data');
 console.log('BOOKING COPILOT DSH PLUGIN PROOF: exact six typed tools/no Book OK');
-
-
-//# sourceURL=ts/scripts/booking-copilot-dsh-plugin-proof-tests.ts

package/dist/scripts/booking-copilot-event-sequence-concurrency-proof-tests.js

@@ -1,3 +1,9 @@
+/**
+ * Real multi-process proof for task-scoped Booking Copilot event sequencing.
+ *
+ * Run from the repository root with Node 24:
+ *   npx tsx ts/scripts/booking-copilot-event-sequence-concurrency-proof-tests.ts
+ */
 import assert from 'node:assert/strict';
 import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
 import { spawn } from 'node:child_process';
@@ -8,35 +14,14 @@ import { ensureLedger } from '../src/state-ledger.js';
 import { BookingCopilotTaskRuntime } from '../src/booking-surface/runtime.js';
 const taskId = 'task-event-sequence-atomicity';
 const workspace = {
-    schemaVersion: 'booking.surface',
-    contextRef: 'ctx-event-sequence-atomicity',
-    surface: 'tenant',
-    revision: 0,
-    locale: 'en-US',
-    currency: 'AED',
-    searchDraft: {},
-    results: {
-        status: 'idle'
-    },
-    visibleHotels: [],
-    loadedOffers: [],
-    shortlistedOfferRefs: [],
-    capabilities: {
-        surface: 'tenant',
-        allowedActions: [
-            'search.run'
-        ]
-    }
+    schemaVersion: 'booking.surface', contextRef: 'ctx-event-sequence-atomicity', surface: 'tenant', revision: 0,
+    locale: 'en-US', currency: 'AED', searchDraft: {}, results: { status: 'idle' }, visibleHotels: [], loadedOffers: [], shortlistedOfferRefs: [],
+    capabilities: { surface: 'tenant', allowedActions: ['search.run'] },
 };
 const turn = {
-    schemaVersion: 'booking.surface',
-    kind: 'user.turn',
-    taskId,
+    schemaVersion: 'booking.surface', kind: 'user.turn', taskId,
     turnId: 'seq-anchor-turn',
-    workspace,
-    request: {
-        text: 'opaque user turn'
-    }
+    workspace, request: { text: 'opaque user turn' },
 };
 const childIndex = process.argv.indexOf('--child');
 const child = childIndex >= 0;
@@ -45,17 +30,20 @@ const childMode = child ? process.argv[childIndex + 2] : undefined;
 const childVariant = child ? process.argv[childIndex + 3] : undefined;
 function sleepWhile(predicate, timeoutMs = 10_000) {
     const deadline = Date.now() + timeoutMs;
-    while(!predicate()){
-        if (Date.now() > deadline) throw new Error('proof_barrier_timeout');
+    while (!predicate()) {
+        if (Date.now() > deadline)
+            throw new Error('proof_barrier_timeout');
         Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 5);
     }
 }
 function waitForFile(path, timeoutMs = 10_000) {
-    return new Promise((resolve, reject)=>{
+    return new Promise((resolve, reject) => {
         const deadline = Date.now() + timeoutMs;
-        const poll = ()=>{
-            if (existsSync(path)) return resolve();
-            if (Date.now() > deadline) return reject(new Error(`proof_file_timeout:${path}`));
+        const poll = () => {
+            if (existsSync(path))
+                return resolve();
+            if (Date.now() > deadline)
+                return reject(new Error(`proof_file_timeout:${path}`));
             setTimeout(poll, 5);
         };
         poll();
@@ -64,39 +52,25 @@ function waitForFile(path, timeoutMs = 10_000) {
 function runChild(root, mode, variant) {
     const script = fileURLToPath(import.meta.url);
     const tsx = fileURLToPath(new URL('../node_modules/tsx/dist/cli.mjs', import.meta.url));
-    const processChild = spawn(process.execPath, [
-        tsx,
-        script,
-        '--child',
-        root,
-        mode,
-        variant
-    ], {
-        cwd: process.cwd(),
-        stdio: [
-            'ignore',
-            'pipe',
-            'pipe'
-        ]
+    const processChild = spawn(process.execPath, [tsx, script, '--child', root, mode, variant], {
+        cwd: process.cwd(), stdio: ['ignore', 'pipe', 'pipe'],
     });
     let output = '';
-    processChild.stdout.on('data', (chunk)=>{
-        output += chunk.toString();
-    });
-    processChild.stderr.on('data', (chunk)=>{
-        output += chunk.toString();
-    });
-    return new Promise((resolve, reject)=>{
-        const timer = setTimeout(()=>{
+    processChild.stdout.on('data', (chunk) => { output += chunk.toString(); });
+    processChild.stderr.on('data', (chunk) => { output += chunk.toString(); });
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
             processChild.kill('SIGKILL');
             reject(new Error(`child_timeout:${mode}:${variant}:${output}`));
         }, 15_000);
-        processChild.on('exit', (code)=>{
+        processChild.on('exit', (code) => {
             clearTimeout(timer);
-            if (code !== 0) return reject(new Error(`child_exit_${code}:${mode}:${variant}:${output}`));
+            if (code !== 0)
+                return reject(new Error(`child_exit_${code}:${mode}:${variant}:${output}`));
             try {
                 resolve(JSON.parse(output.trim().split('\n').at(-1)));
-            } catch (error) {
+            }
+            catch (error) {
                 reject(new Error(`child_output_invalid:${mode}:${variant}:${output}:${error}`));
             }
         });
@@ -109,98 +83,74 @@ if (child) {
     const ledger = ensureLedger(root);
     const runtime = new BookingCopilotTaskRuntime(ledger);
     writeFileSync(join(root, `started-${mode}-${variant}`), 'started');
-    sleepWhile(()=>existsSync(join(root, 'start')));
+    sleepWhile(() => existsSync(join(root, 'start')));
+    // The old implementation read the task outside its write transaction. This
+    // barrier makes both workers hold the same stale fold before either append;
+    // an immediate transaction permits only one worker to reach this point.
     const originalResume = runtime.resumeTask.bind(runtime);
     let firstRead = true;
-    runtime.resumeTask = (id)=>{
+    runtime.resumeTask = (id) => {
         const state = originalResume(id);
         if (firstRead && state) {
             firstRead = false;
             writeFileSync(join(root, `ready-${mode}-${variant}`), 'ready');
-            sleepWhile(()=>existsSync(join(root, 'release')));
+            sleepWhile(() => existsSync(join(root, 'release')));
         }
         return state;
     };
     try {
-        if (mode === 'user-turn') runtime.startTask({
-            ...turn,
-            turnId: `seq-${variant}-turn`
-        });
-        const event = runtime.emitEvent(taskId, {
-            kind: 'status',
-            status: 'working'
-        });
-        console.log(JSON.stringify({
-            event: {
-                sequence: event.sequence
-            }
-        }));
-    } catch (error) {
-        console.log(JSON.stringify({
-            error: error instanceof Error ? error.message : String(error)
-        }));
+        if (mode === 'user-turn')
+            runtime.startTask({ ...turn, turnId: `seq-${variant}-turn` });
+        const event = runtime.emitEvent(taskId, { kind: 'status', status: 'working' });
+        console.log(JSON.stringify({ event: { sequence: event.sequence } }));
+    }
+    catch (error) {
+        console.log(JSON.stringify({ error: error instanceof Error ? error.message : String(error) }));
         process.exitCode = 1;
-    } finally{
+    }
+    finally {
         ledger.close();
     }
-} else {
+}
+else {
     async function run(mode) {
         const root = mkdtempSync(join(tmpdir(), `gotry-event-sequence-${mode}-`));
-        mkdirSync(root, {
-            recursive: true
-        });
+        mkdirSync(root, { recursive: true });
         const ledger = ensureLedger(root);
         new BookingCopilotTaskRuntime(ledger).startTask(turn);
         ledger.close();
-        const children = [
-            runChild(root, mode, 'left'),
-            runChild(root, mode, 'right')
-        ];
+        const children = [runChild(root, mode, 'left'), runChild(root, mode, 'right')];
         try {
             await Promise.all([
                 waitForFile(join(root, `started-${mode}-left`)),
-                waitForFile(join(root, `started-${mode}-right`))
+                waitForFile(join(root, `started-${mode}-right`)),
             ]);
             writeFileSync(join(root, 'start'), 'start');
             await Promise.race([
                 waitForFile(join(root, `ready-${mode}-left`)),
-                waitForFile(join(root, `ready-${mode}-right`))
+                waitForFile(join(root, `ready-${mode}-right`)),
             ]);
-            await new Promise((resolve)=>setTimeout(resolve, 250));
+            await new Promise((resolve) => setTimeout(resolve, 250));
             assert.equal(existsSync(join(root, `ready-${mode}-left`)) && existsSync(join(root, `ready-${mode}-right`)), false, `${mode} workers both derived state before the first transaction committed`);
             writeFileSync(join(root, 'release'), 'release');
             const results = await Promise.all(children);
-            assert.deepEqual(results.map((result)=>result.error), [
-                undefined,
-                undefined
-            ]);
+            assert.deepEqual(results.map((result) => result.error), [undefined, undefined]);
             const check = ensureLedger(root);
             const rows = check.db.prepare("SELECT payload FROM events WHERE tenant_id = ? AND run_id = ? AND kind = 'booking.copilot.event.emitted' ORDER BY seq").all(check.tenant, taskId);
-            const sequences = rows.map((row)=>JSON.parse(row.payload).sequence);
-            assert.deepEqual(sequences, [
-                1,
-                2
-            ], `${mode} durable event sequences must be unique and strictly monotonic`);
-            assert.deepEqual(results.map((result)=>result.event?.sequence).sort((a, b)=>a - b), [
-                1,
-                2
-            ]);
+            const sequences = rows.map((row) => JSON.parse(row.payload).sequence);
+            assert.deepEqual(sequences, [1, 2], `${mode} durable event sequences must be unique and strictly monotonic`);
+            assert.deepEqual(results.map((result) => result.event?.sequence).sort((a, b) => a - b), [1, 2]);
             if (mode === 'user-turn') {
                 const userTurns = check.db.prepare("SELECT COUNT(*) AS n FROM events WHERE tenant_id = ? AND run_id = ? AND kind = 'booking.copilot.user.turn.observed'").get(check.tenant, taskId);
                 assert.equal(userTurns.n, 3, 'initial plus two concurrent user turns must all be durable');
             }
             check.close();
-        } finally{
-            rmSync(root, {
-                recursive: true,
-                force: true
-            });
+        }
+        finally {
+            rmSync(root, { recursive: true, force: true });
         }
     }
     await run('emit');
     await run('user-turn');
     console.log('BOOKING COPILOT EVENT SEQUENCE CONCURRENCY PROOF: emit/user-turn multi-process sequence unique and strictly monotonic');
 }
-
-
-//# sourceURL=ts/scripts/booking-copilot-event-sequence-concurrency-proof-tests.ts

package/dist/scripts/booking-copilot-gap-code-contract-proof-tests.js

@@ -1,3 +1,14 @@
+/**
+ * Cross-repository proof for the Portal sequential HotelRates gap contract.
+ *
+ * The Portal keeps the hotel identity in opaque factRefs while emitting only
+ * fixed safe identifiers in resultContract.gapCodes. This proof calls the
+ * actual GoTry receipt validator so a dynamic legacy code cannot cross the
+ * contract boundary.
+ *
+ * Run from the repository root with Node 24:
+ *   npx tsx ts/scripts/booking-copilot-gap-code-contract-proof-tests.ts
+ */
 import assert from 'node:assert/strict';
 import { validateBookingSurface } from '../src/booking-surface/validation.js';
 const receiptBase = {
@@ -5,104 +16,55 @@ const receiptBase = {
     kind: 'action.receipt',
     actionId: 'offers-query-gap-contract',
     contextRef: 'ctx-gap-contract',
-    revision: 1
+    revision: 1,
 };
 const ratesFailedResult = {
     outcome: 'partial',
     requestedCount: 1,
     actualCount: 1,
     hardCriteriaMet: true,
-    factRefs: [
-        'hotel:hotel-1',
-        'hotel:hotel-2',
-        'offer:breakfast'
-    ]
+    factRefs: ['hotel:hotel-1', 'hotel:hotel-2', 'offer:breakfast'],
 };
 const ratesFailedObservation = {
     kind: 'offers.state',
-    hotelRefs: [
-        'hotel-2'
-    ],
-    offerRefs: [
-        'breakfast'
-    ],
-    loadedHotelCount: 1
+    hotelRefs: ['hotel-2'],
+    offerRefs: ['breakfast'],
+    loadedHotelCount: 1,
 };
 const oldRatesFailedReceipt = {
     ...receiptBase,
     status: 'partial',
     observation: ratesFailedObservation,
-    resultContract: {
-        ...ratesFailedResult,
-        gapCodes: [
-            'hotel_rates_failed:hotel-1'
-        ],
-        blockers: [],
-        relaxationsApplied: []
-    }
+    resultContract: { ...ratesFailedResult, gapCodes: ['hotel_rates_failed:hotel-1'], blockers: [], relaxationsApplied: [] },
 };
 const newRatesFailedReceipt = {
     ...oldRatesFailedReceipt,
-    resultContract: {
-        ...ratesFailedResult,
-        gapCodes: [
-            'hotel_rates_failed'
-        ],
-        blockers: [],
-        relaxationsApplied: []
-    }
+    resultContract: { ...ratesFailedResult, gapCodes: ['hotel_rates_failed'], blockers: [], relaxationsApplied: [] },
 };
 assert.equal(validateBookingSurface(oldRatesFailedReceipt).ok, false, 'legacy dynamic supplier gap code must fail validation');
-assert.deepEqual(validateBookingSurface(newRatesFailedReceipt), {
-    ok: true
-}, 'fixed supplier gap code with hotel fact ref must validate');
-assert.deepEqual(newRatesFailedReceipt.resultContract.factRefs, [
-    'hotel:hotel-1',
-    'hotel:hotel-2',
-    'offer:breakfast'
-]);
+assert.deepEqual(validateBookingSurface(newRatesFailedReceipt), { ok: true }, 'fixed supplier gap code with hotel fact ref must validate');
+assert.deepEqual(newRatesFailedReceipt.resultContract.factRefs, ['hotel:hotel-1', 'hotel:hotel-2', 'offer:breakfast']);
 const oldNotVisibleReceipt = {
     ...receiptBase,
     actionId: 'offers-query-hidden-hotel-gap-contract',
     status: 'no_match',
-    observation: {
-        kind: 'offers.state',
-        hotelRefs: [],
-        offerRefs: [],
-        loadedHotelCount: 0
-    },
+    observation: { kind: 'offers.state', hotelRefs: [], offerRefs: [], loadedHotelCount: 0 },
     resultContract: {
         outcome: 'empty',
         requestedCount: 1,
         actualCount: 0,
         hardCriteriaMet: false,
-        factRefs: [
-            'hotel:not-visible'
-        ],
-        gapCodes: [
-            'hotel_not_visible:not-visible'
-        ],
+        factRefs: ['hotel:not-visible'],
+        gapCodes: ['hotel_not_visible:not-visible'],
         blockers: [],
-        relaxationsApplied: []
-    }
+        relaxationsApplied: [],
+    },
 };
 const newNotVisibleReceipt = {
     ...oldNotVisibleReceipt,
-    resultContract: {
-        ...oldNotVisibleReceipt.resultContract,
-        gapCodes: [
-            'hotel_not_visible'
-        ]
-    }
+    resultContract: { ...oldNotVisibleReceipt.resultContract, gapCodes: ['hotel_not_visible'] },
 };
 assert.equal(validateBookingSurface(oldNotVisibleReceipt).ok, false, 'legacy dynamic visibility gap code must fail validation');
-assert.deepEqual(validateBookingSurface(newNotVisibleReceipt), {
-    ok: true
-}, 'fixed visibility gap code with hotel fact ref must validate');
-assert.deepEqual(newNotVisibleReceipt.resultContract.factRefs, [
-    'hotel:not-visible'
-]);
+assert.deepEqual(validateBookingSurface(newNotVisibleReceipt), { ok: true }, 'fixed visibility gap code with hotel fact ref must validate');
+assert.deepEqual(newNotVisibleReceipt.resultContract.factRefs, ['hotel:not-visible']);
 console.log('BOOKING COPILOT GAP CODE CONTRACT PROOF: dynamic legacy gap codes fail; fixed codes with hotel factRefs pass');
-
-
-//# sourceURL=ts/scripts/booking-copilot-gap-code-contract-proof-tests.ts