firedrill-run 2.2.5 → 3.0.0

package/dist/cli/src/world-time-report.js

@@ -0,0 +1,58 @@
+import { api } from './auth.js';
+import { CliError } from './http.js';
+import { selectOne } from './prompts.js';
+const quote = (value) => `'${value.replaceAll("'", "'\\''")}'`;
+export async function worldTimeReport(path, scope, interactive, options, output, supplied, suppliedKind) {
+    const auth = { actor: scope.owner, workspace: scope.workspace, signal: options.signal };
+    const parts = path.split('/');
+    const command = `firedrill report ${parts.at(-3)} drill ${parts.at(-1)} schedule`;
+    let event = supplied;
+    if (event && !/^[a-f0-9]{64}$/.test(event) || suppliedKind && !['changes', 'conditions'].includes(suppliedKind)
+        || !event && options.search)
+        throw new CliError('arguments_invalid', 'Choose a schedule event ID, then changes or conditions. Search applies to that event’s entries.', 2);
+    if (!event) {
+        let page = Number(options.page ?? '1');
+        while (true) {
+            const data = await api(`${path}/world-time?page=${page}`, auth);
+            output(data, [...data.results.map(row => [`Attempt ${row.attempt_number}: ${row.before_turn === null ? row.kind === 'world.time.started' ? 'Schedule started' : 'Schedule stopped' : `Before conversation turn ${row.before_turn + 1}`}`,
+                    `Scheduled position: ${row.world_at}; offset ${row.offset_ms}ms. Recorded: ${row.recorded_at}.`,
+                    `${row.change_count.toLocaleString()} changes committed; ${row.condition_count.toLocaleString()} record conditions checked.`,
+                    ...(row.events_pending === null ? [] : [`${row.events_pending.toLocaleString()} changes pending. Unreached offsets and unmet conditions are not agent failures.`]),
+                    ...(row.reconciliation_required ? ['Possible changes could not be confirmed and were not automatically replayed.'] : []), row.id].join('\n')),
+                ...(!data.count ? ['No world schedule observations are available.'] : []), `Page ${data.page}; ${data.count.toLocaleString()} observations.`,
+                ...(data.next ? [`Continue: ${command} --workspace ${scope.workspace} --page ${page + 1}`] : []),
+                'Schedule offsets are not runtime or an acceleration measurement.'].join('\n\n'));
+            if (!interactive || !data.count)
+                return;
+            const choices = data.results.filter(row => row.change_count || row.condition_count).map(row => ({ value: row.id,
+                label: `Attempt ${row.attempt_number}, before turn ${(row.before_turn ?? 0) + 1}`, detail: `${row.change_count} changes; ${row.condition_count} conditions` }));
+            if (page > 1)
+                choices.push({ value: 'previous', label: 'Previous page', detail: '' });
+            if (data.next)
+                choices.push({ value: 'next', label: 'Next page', detail: '' });
+            choices.push({ value: 'done', label: 'Done', detail: '' });
+            const selected = await selectOne('Inspect world schedule', choices, options.signal);
+            if (selected === 'done')
+                return;
+            if (selected === 'previous') {
+                page -= 1;
+                continue;
+            }
+            if (selected === 'next') {
+                page += 1;
+                continue;
+            }
+            event = selected;
+            break;
+        }
+    }
+    const kind = suppliedKind ?? (interactive ? await selectOne('Inspect event', [{ value: 'changes', label: 'Committed changes' }, { value: 'conditions', label: 'Record conditions' }], options.signal) : 'changes');
+    const page = supplied ? options.page ?? '1' : '1';
+    const search = supplied ? options.search ?? '' : '';
+    const data = await api(`${path}/world-time/${event}/${kind}?page=${page}&q=${encodeURIComponent(search)}`, auth);
+    output(data, [...data.results.map(row => 'met' in row ? `${row.id}: ${row.met ? 'Condition met' : 'Condition not met'}\n${row.collection}`
+            : `${row.id}: ${row.action} · ${row.collection}\n${row.changed_rows} rows changed at offset ${row.offset_ms}ms.`),
+        ...(!data.count ? ['No matching event entries.'] : []), `Page ${data.page}; ${data.count.toLocaleString()} matching entries.`,
+        ...(data.next ? [`Continue: ${command} ${event} ${kind} --workspace ${scope.workspace} --page ${data.page + 1}${search ? ' --search ' + quote(search) : ''}`] : []),
+        ...(kind === 'conditions' ? ['An unmet condition leaves its record change pending. It is not an agent evaluation result.'] : [])].join('\n\n'));
+}

package/dist/contracts/agent-change-contracts.js

@@ -0,0 +1,75 @@
+import { nativeMetadataCanonical } from './local-value-source-contracts.js';
+const uuid = (v) => typeof v === 'string' && /^[a-f0-9]{8}(?:-[a-f0-9]{4}){3}-[a-f0-9]{12}$/.test(v);
+const hex = (v) => typeof v === 'string' && /^[a-f0-9]{64}$/.test(v);
+const date = (v) => typeof v === 'string' && Number.isFinite(Date.parse(v));
+const integer = (v, minimum = 0) => typeof v === 'number' && Number.isSafeInteger(v) && v >= minimum;
+export function sourceChangeRead(v, matches) {
+    if (!matches)
+        throw new Error('The source-change response did not match this workspace, baseline or original reviewed source. Inspect the original request before continuing. No replacement request was submitted.');
+    return v;
+}
+export const patchSourceFileMatches = (v) => !!v && typeof v.path === 'string' && v.path.length > 0
+    && v.path.length <= 1024 && hex(v.sha256) && integer(v.size) && [420, 493].includes(v.mode);
+export function sourceChangeMatches(v, workspace, campaign, change) {
+    return !!v && uuid(v.id) && (!change || v.id === change) && v.workspace_id === workspace && v.baseline_id === campaign
+        && [v.world_id, v.source_id, v.request_key, v.proposed_by_id].every(uuid) && typeof v.title === 'string'
+        && typeof v.instruction === 'string' && ['pending', 'approved', 'drafted', 'creating', 'accepted', 'dismissed'].includes(v.state)
+        && typeof v.current === 'boolean' && typeof v.comparison_available === 'boolean' && hex(v.scope_sha256)
+        && (v.draft_sha256 === null || hex(v.draft_sha256)) && date(v.expires_at) && typeof v.source_revision === 'string'
+        && [v.candidate_source_id, v.candidate_world_id, v.approved_by_id].every(one => one === null || uuid(one))
+        && (v.approved_at === null || date(v.approved_at)) && (v.problem === null || typeof v.problem === 'string')
+        && Array.isArray(v.files) && new Set(v.files.map(one => one.path)).size === v.files.length && v.files.every(patchSourceFileMatches)
+        && (v.draft_files === undefined || Array.isArray(v.draft_files) && v.draft_files.length <= v.files.length
+            && new Set(v.draft_files.map(one => one.path)).size === v.draft_files.length
+            && v.draft_files.every(one => one && typeof one.path === 'string' && hex(one.sha256) && hex(one.before_sha256) && integer(one.size)
+                && v.files.some(original => original.path === one.path && original.sha256 === one.before_sha256)));
+}
+export function sourceChangeProposalMatches(v, workspace, campaign, actor, key, body) {
+    return sourceChangeMatches(v, workspace, campaign) && v.proposed_by_id === actor && v.request_key === key
+        && v.title === body.title.trim() && v.instruction === body.instruction.trim()
+        && nativeMetadataCanonical(v.files.map(one => one.path).sort()) === nativeMetadataCanonical([...body.paths].sort());
+}
+export function sourceChangeCommandMatches(v, workspace, campaign, change, actor, key, body, digest) {
+    return sourceChangeMatches(v, workspace, campaign, change) && v.scope_sha256 === body.scope_sha256
+        && (body.action !== 'accept' || v.draft_sha256 === body.draft_sha256) && !!v.command_receipt
+        && v.command_receipt.actor_id === actor && v.command_receipt.request_key === key && v.command_receipt.action === body.action
+        && v.command_receipt.command_sha256 === digest && typeof v.command_receipt.recovered === 'boolean';
+}
+export function sourceChangePageMatches(v, workspace, campaign, page) {
+    return !!v && v.workspace_id === workspace && v.baseline_id === campaign && v.page === page && integer(v.count)
+        && integer(v.page_size, 1) && v.page_size <= 100 && Array.isArray(v.results) && v.results.length <= v.page_size;
+}
+export function sourceChangeDiffMatches(v, row, file, position) {
+    return !!v && v.workspace_id === row.workspace_id && v.baseline_id === row.baseline_id && v.change_id === row.id
+        && v.source_id === row.source_id && v.scope_sha256 === row.scope_sha256 && v.draft_sha256 === row.draft_sha256
+        && v.position === position && v.path === file.path && v.before_sha256 === file.before_sha256 && v.after_sha256 === file.sha256
+        && typeof v.diff === 'string';
+}
+export function agentComparisonMatches(v, workspace, campaign, change) {
+    return !!v && uuid(v.id) && v.workspace_id === workspace && v.baseline_id === campaign && v.change_id === change
+        && uuid(v.actor_id) && uuid(v.request_key) && hex(v.request_digest) && hex(v.sha256)
+        && ['queued', 'prepared', 'unavailable'].includes(v.state) && (v.current === null || typeof v.current === 'boolean')
+        && [v.retained_count, v.additional_count, v.criterion_count].every(one => integer(one))
+        && [v.repetitions, v.parallelism, v.trial_seconds].every(one => integer(one, 1))
+        && [v.control_world_id, v.candidate_world_id].every(one => one === null || uuid(one))
+        && (v.problem === null || typeof v.problem === 'string');
+}
+export function agentComparisonRequestMatches(v, workspace, campaign, change, actor, key) {
+    return sourceChangePageMatches(v, workspace, campaign, 1) && v.change_id === change && v.count <= 1
+        && v.results.length === v.count && v.results.every(row => agentComparisonMatches(row, workspace, campaign, change)
+        && row.actor_id === actor && row.request_key === key);
+}
+export function candidateSourceMatches(v, workspace, campaign, change) {
+    return !!v && v.schema === 'firedrill.agent-change-export.v1' && v.workspace_id === workspace && v.baseline_id === campaign
+        && v.change_id === change && [v.source_id, v.world_id, v.agent_id, v.snapshot?.id].every(uuid)
+        && [v.scope_sha256, v.draft_sha256, v.files_sha256, v.snapshot?.sha256].every(hex)
+        && !!v.capacity && Object.keys(v.capacity).sort().join(',') === 'archive_bytes,directory_bytes,expanded_bytes,file_bytes,files'
+        && Object.values(v.capacity).every(one => integer(one, 1)) && integer(v.snapshot.size, 1) && v.snapshot.size <= v.capacity.archive_bytes
+        && typeof v.snapshot.generation === 'string' && /^[1-9][0-9]{0,30}$/.test(v.snapshot.generation)
+        && integer(v.file_count, 1) && v.file_count <= v.capacity.files && integer(v.expanded_bytes) && v.expanded_bytes <= v.capacity.expanded_bytes
+        && v.target_executed === false && v.vault_access_inherited === false;
+}
+export async function sourceMetadataDigest(value) {
+    const hash = await crypto.subtle.digest('SHA-256', new TextEncoder().encode(nativeMetadataCanonical(value)));
+    return Array.from(new Uint8Array(hash), one => one.toString(16).padStart(2, '0')).join('');
+}

package/dist/contracts/agent-execution-contracts.js

@@ -0,0 +1,38 @@
+const record = (value) => Boolean(value && typeof value === 'object' && !Array.isArray(value));
+const hash = (value) => typeof value === 'string' && /^[a-f0-9]{64}$/.test(value);
+const fields = (value, names) => Object.keys(value).sort().join(',') === names.sort().join(',');
+export function driverBasisMatches(value) {
+    return record(value) && fields(value, ['source_set_sha256', 'graph_sha256', 'configuration_sha256', 'world_revision'])
+        && ['source_set_sha256', 'graph_sha256', 'configuration_sha256'].every(key => hash(value[key]))
+        && typeof value.world_revision === 'string' && value.world_revision.length > 0 && value.world_revision.length <= 128;
+}
+export function executionDriverMatches(value) {
+    return record(value) && fields(value, ['schema', 'contract_sha256', 'input_scope_sha256', 'kind', 'requires_input', 'uses_participant_model', 'revision', 'basis', 'readiness',
+        ...('scheduled_after_ms' in value ? ['scheduled_after_ms'] : [])])
+        && value.schema === 'firedrill.agent-execution.v1' && hash(value.contract_sha256) && hash(value.input_scope_sha256)
+        && typeof value.kind === 'string' && ['conversation', 'http_task', 'browser_workflow', 'adaptive_browser', 'desktop', 'process', 'event'].includes(value.kind)
+        && value.requires_input === !['conversation', 'http_task'].includes(value.kind)
+        && value.uses_participant_model === ['adaptive_browser', 'desktop'].includes(value.kind)
+        && (value.scheduled_after_ms == null || value.kind === 'event' && Number.isSafeInteger(value.scheduled_after_ms)
+            && value.scheduled_after_ms >= 0 && value.scheduled_after_ms < 30 * 86400 * 1000)
+        && typeof value.revision === 'string' && /^[A-Za-z0-9][A-Za-z0-9_.-]{0,127}$/.test(value.revision)
+        && driverBasisMatches(value.basis) && value.readiness === 'not_executed';
+}
+export function executionScheduleText(driver) {
+    if (driver.kind !== 'event' || driver.scheduled_after_ms == null)
+        return null;
+    if (driver.scheduled_after_ms === 0)
+        return 'Send the event without a scheduled delay.';
+    const seconds = driver.scheduled_after_ms / 1000;
+    const duration = seconds < 60 ? `${seconds.toLocaleString()} seconds`
+        : seconds < 3600 ? `${(seconds / 60).toLocaleString(undefined, { maximumFractionDigits: 2 })} minutes`
+            : `${(seconds / 3600).toLocaleString(undefined, { maximumFractionDigits: 2 })} hours`;
+    return `Wait ${duration} before sending the event. This delay uses real time and counts toward the drill time limit.`;
+}
+export function executionAuthorityMatches(value, driver) {
+    if (!driver?.requires_input)
+        return value === null;
+    return record(value) && fields(value, ['schema', 'contract_sha256', 'input_authorized', 'simulated_only', 'allowed_kind'])
+        && value.schema === 'firedrill.agent-execution-authority.v1' && value.contract_sha256 === driver.contract_sha256
+        && value.input_authorized === true && value.simulated_only === true && value.allowed_kind === driver.kind;
+}

package/dist/contracts/application-state-contracts.js

@@ -0,0 +1,26 @@
+const uuid = /^[a-f0-9]{8}(?:-[a-f0-9]{4}){3}-[a-f0-9]{12}$/, hash = /^[a-f0-9]{64}$/;
+export function applicationCheckpointMatches(value, world, selected = {}) {
+    return !!value && uuid.test(value.id) && value.world_id === world && uuid.test(value.session_id)
+        && (selected.session === undefined || value.session_id === selected.session) && (selected.id === undefined || value.id === selected.id)
+        && (selected.key === undefined || value.request_key === selected.key) && typeof value.request_key === 'string' && value.request_key.length > 0
+        && ['pending', 'retained', 'unavailable'].includes(value.state) && typeof value.available === 'boolean' && value.controlled_services_included === false
+        && typeof value.name === 'string' && value.name.length > 0 && value.name.length <= 120 && Number.isFinite(Date.parse(value.created_at))
+        && (value.captured_at === null || Number.isFinite(Date.parse(value.captured_at))) && Array.isArray(value.components) && value.components.length <= 1000
+        && value.components.every(one => !!one && typeof one.name === 'string' && one.name.length > 0
+            && ['application_memory', 'database', 'files', 'queue_cursor', 'conversation', 'scheduled_jobs'].includes(one.kind)
+            && ['application_consistent', 'crash_consistent'].includes(one.consistency))
+        && Array.isArray(value.excluded) && value.excluded.length <= 1000 && value.excluded.every(one => typeof one === 'string' && one.length > 0 && one.length <= 256)
+        && (value.event_watermark === null || typeof value.event_watermark === 'string' && value.event_watermark.length > 0 && value.event_watermark.length <= 256)
+        && (!value.available || value.state === 'retained' && value.captured_at !== null && value.components.length > 0 && value.excluded.length > 0);
+}
+export function applicationStateReference(value) {
+    const row = value;
+    return !!row && typeof row === 'object' && !Array.isArray(row) && Object.keys(row).sort().join(',') === 'archive_id,checkpoint_id,checkpoint_session_id,components,continuity,controlled_services_included,driver_digest,event_watermark,excluded,generation,sha256,size'
+        && [row.checkpoint_id, row.checkpoint_session_id, row.archive_id].every(one => typeof one === 'string' && uuid.test(one))
+        && [row.sha256, row.driver_digest].every(one => typeof one === 'string' && hash.test(one)) && Number.isSafeInteger(row.size) && row.size > 0 && row.size <= 8 * 1024 ** 2
+        && typeof row.generation === 'string' && /^[1-9][0-9]{0,30}$/.test(row.generation) && row.controlled_services_included === false && row.continuity === 'application_supported_new_process'
+        && typeof row.event_watermark === 'string' && row.event_watermark.length > 0 && row.event_watermark.length <= 256 && !/[\u0000-\u001f\u007f]/.test(row.event_watermark)
+        && Array.isArray(row.components) && row.components.length > 0 && row.components.length <= 1000 && row.components.every(one => !!one && typeof one.name === 'string' && one.name.length > 0
+        && ['application_memory', 'database', 'files', 'queue_cursor', 'conversation', 'scheduled_jobs'].includes(one.kind) && ['application_consistent', 'crash_consistent'].includes(one.consistency))
+        && Array.isArray(row.excluded) && row.excluded.length > 0 && row.excluded.length <= 1000 && row.excluded.every(one => typeof one === 'string' && one.length > 0 && one.length <= 256);
+}

package/dist/contracts/assessment-aggregate-contracts.js

@@ -0,0 +1,15 @@
+import { memoryProbeMatches } from './revision-contracts.js';
+export function scoreCohortMatches(actual, expected) {
+    return actual.assessment_id === expected.assessment_id
+        && (expected.identity === undefined || actual.identity === expected.identity);
+}
+export function checkpointMatches(page, assessment, index, expected) {
+    const probe = page.cohort.memory.probes[index];
+    return page.cohort.assessment_id === assessment && !!probe && memoryProbeMatches(page.probe, probe)
+        && (!expected || page.cohort.scenario_id === expected.scenario_id && page.cohort.rubric_digest === expected.rubric_digest
+            && page.cohort.model === expected.model && page.cohort.requested_model === expected.requested_model);
+}
+export function styleCohortMatches(actual, expected) {
+    return actual.assessment_id === expected.assessment_id && (expected.identity === undefined || actual.identity === expected.identity)
+        && (expected.parser === undefined || actual.parser === expected.parser);
+}

package/dist/contracts/assessment-contracts.js

@@ -0,0 +1,74 @@
+const uuid = (value) => typeof value === 'string'
+    && /^[a-f0-9]{8}(?:-[a-f0-9]{4}){3}-[a-f0-9]{12}$/.test(value);
+const keyPattern = /^[A-Za-z0-9][A-Za-z0-9:._-]{0,127}$/;
+function checkpointMatches(value, partial) {
+    return value === null || !!value && partial === true && value.schema === 'firedrill.assessment-checkpoint.v1'
+        && /^[a-f0-9]{64}$/.test(value.event_id) && uuid(value.attempt_id) && uuid(value.stream_id)
+        && Number.isSafeInteger(value.attempt_number) && value.attempt_number >= 1
+        && Number.isSafeInteger(value.turn) && value.turn >= 2 && value.turn <= 100000
+        && Number.isFinite(Date.parse(value.observed_at)) && (value.artifact_ceiling === null
+        || Number.isSafeInteger(value.artifact_ceiling) && value.artifact_ceiling >= 0 && value.artifact_ceiling <= 9999999999)
+        && (value.world_event_key === undefined && value.world_receipt_event_id === undefined
+            || typeof value.world_event_key === 'string' && /^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$/.test(value.world_event_key)
+                && /^[a-f0-9]{64}$/.test(value.world_receipt_event_id ?? ''));
+}
+export function assessmentMatches(row, campaign, execution, id) {
+    if (!row || !uuid(row.id) || id !== undefined && row.id !== id || row.campaign_id !== campaign
+        || row.execution_id !== execution || !uuid(row.agent_id) || row.provider !== 'Firedrill'
+        || !checkpointMatches(row.checkpoint, row.partial_execution))
+        return false;
+    if (row.state === 'unavailable')
+        return row.result === null && row.evidence_count === null
+            && Object.keys(row.rubric).length === 0;
+    if (!Array.isArray(row.rubric?.levels) || row.rubric.levels.length < 2 || row.rubric.levels.length > 10
+        || !Number.isSafeInteger(row.evidence_count) || row.evidence_count < 0)
+        return false;
+    if (row.result === null)
+        return row.state !== 'succeeded';
+    return !!row.model && ['succeeded', 'not_assessable', 'not_applicable'].includes(row.state)
+        && row.result.status === (row.state === 'succeeded' ? 'assessable' : row.state)
+        && row.result.levels.length === row.rubric.levels.length
+        && row.result.levels.every((level, index) => level === row.rubric.levels[index])
+        && explanationMatches(row.result.explanation)
+        && (row.result.status === 'assessable' ? typeof row.result.score === 'number' && Number.isFinite(row.result.score)
+            && row.result.score >= 0 && row.result.score <= row.result.levels.length - 1 : row.result.score === null);
+}
+function explanationMatches(value) {
+    return !!value && ['queued', 'submitted', 'succeeded', 'failed', 'unknown', 'unavailable'].includes(value.state)
+        && value.attribution === 'evidence_synthesis' && typeof value.requested_model === 'string'
+        && Array.isArray(value.observations) && value.observations.length <= 4 && typeof value.limitation === 'string'
+        && value.observations.every(item => typeof item.text === 'string' && item.text.length > 0 && item.text.length <= 1200
+            && Array.isArray(item.evidence) && item.evidence.length >= 1 && item.evidence.length <= 4
+            && item.evidence.every(ref => ['message', 'action', 'state'].includes(ref.kind) && uuid(ref.id) && uuid(ref.evidence_id)
+                && (ref.kind === 'state' && ref.position === null || typeof ref.position === 'number'
+                    && Number.isSafeInteger(ref.position) && ref.position >= 0)
+                && typeof ref.quote === 'string' && ref.quote.length > 0 && ref.quote.length <= 280)
+            && Array.isArray(item.policies) && item.policies.length <= 4 && item.policies.every(ref => uuid(ref.revision_id)
+            && /^p[0-9]{1,11}$/.test(ref.paragraph_id) && typeof ref.quote === 'string' && ref.quote.length > 0 && ref.quote.length <= 280))
+        && (value.state !== 'succeeded' || typeof value.model === 'string' && value.model.length > 0
+            && /^[a-f0-9]{64}$/.test(value.input_sha256 ?? '') && /^[a-f0-9]{64}$/.test(value.response_sha256 ?? '')
+            && (value.observations.length > 0 || value.limitation.length > 0));
+}
+export function assessmentPageMatches(page, campaign, execution) {
+    return !!page && Array.isArray(page.results) && page.results.every(row => row.campaign_id === campaign
+        && row.execution_id === execution && uuid(row.id) && checkpointMatches(row.checkpoint, row.partial_execution));
+}
+/** Original actor/key acceptance only. Never resubmit a target or evaluator. */
+export function assessmentRequestMatches(row, scope, key) {
+    return !!row && row.schema === 'firedrill.assessment-request-receipt.v1' && row.actor_id === scope.actor
+        && row.workspace_id === scope.workspace && row.campaign_id === scope.campaign && row.execution_id === scope.execution
+        && typeof row.request_key === 'string' && keyPattern.test(row.request_key) && (key === undefined || row.request_key === key)
+        && ['accepted', 'withdrawn', 'not_received'].includes(row.state) && typeof row.resource_available === 'boolean'
+        && (row.resource_available ? row.state === 'accepted' && uuid(row.assessment_id) && typeof row.assessment_state === 'string'
+            : row.assessment_id === null && row.assessment_state === null);
+}
+export function assessmentAcceptanceMatches(receipt, row, scope, key) {
+    return assessmentRequestMatches(receipt, scope, key) && assessmentMatches(row, scope.campaign, scope.execution)
+        && receipt.state === 'accepted' && receipt.resource_available && receipt.assessment_id === row.id;
+}
+export function assessmentEvidenceMatches(row, expected) {
+    const position = expected.kind === 'state' ? row.sequence : row.position;
+    return uuid(row.id) && uuid(row.evidence_id) && row.id === expected.id && row.evidence_id === expected.evidence_id
+        && position === expected.position && (expected.kind === 'state' && position === null
+        || typeof position === 'number' && Number.isSafeInteger(position) && position >= 0);
+}

package/dist/contracts/billing-commerce-contracts.js

@@ -0,0 +1,107 @@
+const uuid = (v) => typeof v === 'string' && /^[a-f0-9]{8}(?:-[a-f0-9]{4}){3}-[a-f0-9]{12}$/.test(v);
+const date = (v) => typeof v === 'string' && Number.isFinite(Date.parse(v));
+const integer = (v) => typeof v === 'number' && Number.isSafeInteger(v);
+const count = (v) => integer(v) && v >= 0;
+const text = (v, limit = 128) => typeof v === 'string' && v.length <= limit && !/[\u0000-\u001f\u007f]/.test(v);
+const invoiceId = (v) => typeof v === 'string' && /^in_[A-Za-z0-9_]{1,120}$/.test(v);
+const planOffers = ['starter_monthly', 'starter_annual', 'team_monthly', 'team_annual', 'scale_monthly', 'scale_annual'];
+export function billingPurchaseSelectionMatches(kind, offer, interval) {
+    const plan = (offer === 'starter' || offer === 'team' || offer === 'scale') && (interval === 'monthly' || interval === 'annual');
+    return kind === 'subscription' ? plan : kind === 'portal' ? (offer === '' && interval === '' || plan)
+        : false;
+}
+export function billingCommerceRead(value, matches) {
+    if (!matches)
+        throw new Error('The payment response could not be confirmed for this organization and original request. Inspect its saved request before continuing.');
+    return value;
+}
+function scope(v, workspace, organization) {
+    return !!v && v.selected_workspace_id === workspace && uuid(v.organization_id) && uuid(v.account_id)
+        && (!organization || v.organization_id === organization);
+}
+export function billingOptionsMatch(v, workspace, actor, organization) {
+    if (!scope(v, workspace, organization) || v.actor_id !== actor || typeof v.available !== 'boolean' || typeof v.portal !== 'boolean'
+        || !Array.isArray(v.plans) || !Array.isArray(v.changes) || !Array.isArray(v.packs) || v.plans.length > 100 || v.packs.length > 100 || v.changes.length > 6
+        || ![...v.plans, ...v.packs].every(one => typeof one === 'string' && /^[a-z0-9_]{1,32}$/.test(one))
+        || !v.changes.every(one => typeof one === 'string' && planOffers.includes(one))
+        || new Set(v.plans).size !== v.plans.length || new Set(v.packs).size !== v.packs.length || new Set(v.changes).size !== v.changes.length
+        || !v.available && (v.portal || v.plans.length > 0 || v.packs.length > 0 || v.changes.length > 0))
+        return false;
+    const row = v.subscription;
+    if (v.changes.length && (!row || row.cancel_at_period_end || row.scheduled_change || v.changes.some(one => one === `${row.plan}_${row.interval}`)))
+        return false;
+    return row === null || !!row && text(row.plan, 24) && text(row.interval, 16) && text(row.status, 24)
+        && [row.period_start, row.period_end, row.observed_at].every(date) && Date.parse(row.period_end) > Date.parse(row.period_start)
+        && typeof row.cancel_at_period_end === 'boolean' && (row.scheduled_change === null || !!row.scheduled_change
+        && text(row.scheduled_change.plan, 24) && text(row.scheduled_change.interval, 16) && date(row.scheduled_change.at));
+}
+export function billingPurchaseMatches(v, workspace, selected = {}) {
+    const denomination = !!v && (v.denomination === null || typeof v.denomination === 'string'
+        && /^[A-Za-z0-9][A-Za-z0-9_.:-]{0,31}$/.test(v.denomination));
+    const knownUnit = !!v && typeof v.denomination === 'string' && denomination
+        && integer(v.credit_scale) && v.credit_scale >= 1 && /^10*$/.test(String(v.credit_scale));
+    const plainPortal = !!v && v.kind === 'portal' && v.amount_cents === 0 && v.units === 0
+        && v.offer === '' && v.interval === '' && v.denomination === null && v.credit_scale === null;
+    if (!scope(v, workspace, selected.organization) || !uuid(v.id) || selected.id && v.id !== selected.id || !uuid(v.actor_id)
+        || v.workspace_id !== null && !uuid(v.workspace_id) || !text(v.request_key) || !v.request_key
+        || !['subscription', 'portal'].includes(v.kind) || !text(v.offer, 32) || !text(v.interval, 16)
+        || !billingPurchaseSelectionMatches(v.kind, v.offer, v.interval)
+        || v.kind === 'portal' && (v.units !== 0 || v.offer === '' && v.interval === '' && v.amount_cents !== 0)
+        || ![v.amount_cents, v.units].every(count) || v.currency !== 'usd' || !text(v.state, 24)
+        || !denomination || !(knownUnit || v.credit_scale === null && (v.url === null || plainPortal))
+        || v.request_state !== null && !text(v.request_state, 24) || !date(v.created_at)
+        || v.expires_at !== null && !date(v.expires_at) || v.message !== undefined && !text(v.message, 512))
+        return false;
+    if (v.url !== null) {
+        try {
+            const link = new URL(v.url);
+            if (link.protocol !== 'https:' || link.host !== (v.kind === 'portal' ? 'billing.stripe.com' : 'checkout.stripe.com')
+                || link.username || link.password || !['awaiting_payment', 'portal_ready'].includes(v.state) || v.request_state !== 'ready' || !v.expires_at)
+                return false;
+        }
+        catch {
+            return false;
+        }
+    }
+    const original = selected.original;
+    return (!original || v.workspace_id === workspace && v.request_key === original.key && v.kind === original.kind && v.offer === original.offer && v.interval === original.interval)
+        && (!selected.actor || v.actor_id === selected.actor);
+}
+export function billingPurchaseRequestMatches(v, workspace, actor, key, original, id, organization) {
+    if (!scope(v, workspace, organization) || v.actor_id !== actor || v.request_key !== key || !uuid(key) || typeof v.requested_by_me !== 'boolean')
+        return false;
+    if (v.state === 'not_received')
+        return !id && !v.requested_by_me && v.purchase === null;
+    return v.state === 'received' && v.requested_by_me && !!v.purchase && v.purchase.account_id === v.account_id
+        && v.purchase.request_key === key && v.purchase.workspace_id === workspace
+        && billingPurchaseMatches(v.purchase, workspace, { id, organization: v.organization_id, actor, original });
+}
+function page(v, workspace, number, organization) {
+    return scope(v, workspace, organization) && v.page === number && count(v.count) && count(v.page_size) && v.page_size >= 1 && v.page_size <= 100
+        && Array.isArray(v.results) && v.results.length <= v.page_size && new Set(v.results.map(one => one.id)).size === v.results.length;
+}
+export function billingPurchasesMatch(v, workspace, status = '', number = 1, organization) {
+    return page(v, workspace, number, organization) && v.status === status && v.results.every(one => one.account_id === v.account_id && one.url === null
+        && billingPurchaseMatches(one, workspace, { organization: v.organization_id }) && (!status || status === effectivePurchaseState(one)));
+}
+export function effectivePurchaseState(v) {
+    return !['paid', 'reversed'].includes(v.state) && ['uncertain', 'failed', 'reconciliation_required'].includes(v.request_state ?? '') ? v.request_state : v.state;
+}
+export function billingInvoiceMatches(v, workspace, id, organization) {
+    return scope(v, workspace, organization) && invoiceId(v.id) && (!id || v.id === id) && text(v.status, 24) && text(v.reconciliation, 24)
+        && [v.subtotal_cents, v.total_cents].every(integer) && [v.paid_cents, v.discount_cents].every(count) && v.currency === 'usd'
+        && date(v.created_at) && date(v.updated_at) && (v.paid_at === null || date(v.paid_at))
+        && [v.plan, v.interval, v.payment_state].every(one => one === null || text(one, 24))
+        && (v.service_starts_at === null && v.service_ends_at === null || date(v.service_starts_at) && date(v.service_ends_at)
+            && Date.parse(v.service_ends_at) > Date.parse(v.service_starts_at));
+}
+export function billingInvoicesMatch(v, workspace, status = '', number = 1, organization) {
+    return page(v, workspace, number, organization) && v.status === status && v.results.every(one => one.account_id === v.account_id
+        && billingInvoiceMatches(one, workspace, undefined, v.organization_id) && (!status || one.status === status));
+}
+export function billingInvoiceLinesMatch(v, workspace, id, number = 1, organization) {
+    return page(v, workspace, number, organization) && v.invoice_id === id && invoiceId(id) && uuid(v.observation_id)
+        && typeof v.collection_complete === 'boolean' && text(v.reconciliation, 24) && v.results.every(one => /^il_[A-Za-z0-9_]{1,120}$/.test(one.id)
+        && text(one.plan, 24) && text(one.interval, 16) && integer(one.amount_cents) && one.currency === 'usd' && typeof one.prorated === 'boolean'
+        && date(one.service_starts_at) && date(one.service_ends_at) && Date.parse(one.service_ends_at) > Date.parse(one.service_starts_at));
+}

package/dist/contracts/billing-wallet-contracts.js

@@ -0,0 +1,43 @@
+const uuid = (v) => typeof v === 'string' && /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/.test(v);
+const count = (v, min = 0) => typeof v === 'number' && Number.isSafeInteger(v) && v >= min;
+const date = (v) => typeof v === 'string' && Number.isFinite(Date.parse(v));
+const denomination = (v) => typeof v === 'string' && /^[a-zA-Z0-9][a-zA-Z0-9_.:-]{0,31}$/.test(v);
+const sources = ['included', 'purchased', 'sponsored', 'adjustment'];
+export function creditUnitMatches(value, nullable = false) {
+    return !!value && (nullable && value.denomination === null && value.credit_scale === null
+        || denomination(value.denomination) && count(value.credit_scale, 1));
+}
+export function billingWalletRead(value, matches) {
+    if (!matches)
+        throw new Error('The billing response did not match this workspace or organization. Reload Billing before continuing.');
+    return value;
+}
+function metadataMatches(v, account) {
+    return !!v && uuid(v.account_id) && (!account || v.account_id === account) && ['free', 'starter', 'team', 'scale', 'enterprise'].includes(v.plan)
+        && typeof v.subscription_state === 'string' && count(v.concurrency, 1) && typeof v.cancel_at_period_end === 'boolean'
+        && [v.next_allocation_at, v.paid_through, v.enterprise_until].every(one => one === null || date(one));
+}
+export function billingBalanceMatches(v, account) {
+    return metadataMatches(v, account) && [v.available, v.reserved, v.debt].every(one => count(one))
+        && creditUnitMatches(v) && typeof v.version === 'string' && !!v.version && typeof v.payment_review_required === 'boolean'
+        && !!v.by_source && !Array.isArray(v.by_source) && Object.entries(v.by_source).every(([key, units]) => sources.includes(key) && count(units))
+        && Object.values(v.by_source).reduce((sum, one) => sum + one, 0) === v.available;
+}
+export function billingSummaryMatches(v, workspace, actor, organization) {
+    if (!metadataMatches(v) || v.workspace_id !== workspace || v.actor_id !== actor || !uuid(v.organization_id)
+        || organization && v.organization_id !== organization || typeof v.organization_name !== 'string'
+        || typeof v.can_manage !== 'boolean' || typeof v.can_redeem !== 'boolean')
+        return false;
+    const catalog = v.catalog;
+    return !!catalog && typeof catalog.version === 'string' && catalog.currency === 'usd' && catalog.unit === 'Resource credits'
+        && (catalog.denomination === null && catalog.credit_scale === null || denomination(catalog.denomination) && count(catalog.credit_scale, 1))
+        && catalog.included_rollover === false && catalog.purchased_units_expire === false
+        && Array.isArray(catalog.plans) && catalog.plans.length > 0 && catalog.plans.length <= 100
+        && catalog.plans.every(plan => typeof plan.name === 'string' && ['free', 'starter', 'team', 'scale', 'enterprise'].includes(plan.key)
+            && [plan.monthly_cents, plan.annual_cents, plan.monthly_units].every(value => value === null || count(value))
+            && (plan.concurrency === null || count(plan.concurrency, 1)) && typeof plan.topups === 'boolean')
+        && catalog.plans.some(plan => plan.key === v.plan) && new Set(catalog.plans.map(one => one.key)).size === catalog.plans.length
+        && Array.isArray(catalog.packs) && catalog.packs.length <= 100
+        && catalog.packs.every(pack => typeof pack.key === 'string' && count(pack.units, 1) && count(pack.amount_cents, 1))
+        && new Set(catalog.packs.map(one => one.key)).size === catalog.packs.length;
+}

package/dist/contracts/campaign-lifecycle.js

@@ -0,0 +1 @@
+export {};

package/dist/contracts/campaign-world-contracts.js

@@ -0,0 +1,80 @@
+const id = (value) => typeof value === 'string' && /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/.test(value);
+const date = (value) => value === null || typeof value === 'string' && Number.isFinite(Date.parse(value));
+const decimal = (value) => typeof value === 'string' && /^(0|[1-9][0-9]{0,20})$/.test(value);
+export function worldControlInputMatches(value) {
+    const one = value;
+    return !!one && typeof one === 'object' && Object.keys(one).sort().join(',') === 'action,expected_sequence,expected_watermark,next_scenario_id,previous_revision'
+        && ['pause', 'resume', 'cancel_future', 'revise_future'].includes(one.action) && /^[a-f0-9]{64}$/.test(one.previous_revision)
+        && typeof one.expected_watermark === 'string' && /^(0|[1-9][0-9]{0,5})$/.test(one.expected_watermark) && BigInt(one.expected_watermark) <= 100000n
+        && Number.isSafeInteger(one.expected_sequence) && one.expected_sequence >= 0 && one.expected_sequence <= 100000
+        && (one.action === 'revise_future' ? id(one.next_scenario_id) : one.next_scenario_id === null);
+}
+export function worldControlMatches(value, scope, original) {
+    if (!value || value.workspace_id !== scope.workspace || value.campaign_id !== scope.campaign || value.execution_id !== scope.execution
+        || scope.actor !== undefined && value.actor_id !== scope.actor || !id(value.id) || !id(value.request_key) || !id(value.actor_id)
+        || !/^[a-f0-9]{64}$/.test(value.command_sha256) || !Number.isSafeInteger(value.sequence) || value.sequence < 1
+        || !['queued', 'publishing', 'unknown', 'observed', 'rejected', 'ended'].includes(value.state)
+        || !['guest_report', 'customer_device'].includes(value.provenance)
+        || value.problem !== undefined && value.problem !== null && typeof value.problem !== 'string'
+        || !worldControlInputMatches({ action: value.action, previous_revision: value.previous_revision, expected_watermark: value.expected_watermark, expected_sequence: value.expected_sequence, next_scenario_id: value.next_scenario_id })
+        || value.sequence !== value.expected_sequence + 1
+        || ![value.not_after, value.created_at].every(at => typeof at === 'string' && date(at)) || ![value.publication_started_at, value.finished_at].every(date))
+        return false;
+    if (original && (original.key !== value.request_key || original.body && Object.keys(original.body).some(key => original.body[key] !== value[key])))
+        return false;
+    return value.result === null || !!value.result && ['observed', 'rejected', 'unknown'].includes(value.result.state)
+        && typeof value.result.code === 'string' && /^[a-f0-9]{64}$/.test(value.result.revision)
+        && Number.isSafeInteger(value.result.watermark) && value.result.watermark >= 0 && typeof value.result.observed_at === 'string' && date(value.result.observed_at);
+}
+export function runtimeRenewalPageMatches(value) {
+    return !!value && Number.isSafeInteger(value.count) && value.count >= 0 && Number.isSafeInteger(value.page) && value.page > 0
+        && Number.isSafeInteger(value.page_size) && value.page_size >= 1 && value.page_size <= 100 && Array.isArray(value.results)
+        && value.results.length <= value.page_size && value.results.every(one => id(one.id) && Number.isSafeInteger(one.sequence) && one.sequence > 0
+        && ['publishing', 'observed', 'unknown', 'ended'].includes(one.state)
+        && [one.requested_at, one.previous_expires_at, one.requested_expires_at].every(at => typeof at === 'string' && date(at))
+        && [one.confirmed_expires_at, one.finished_at].every(date));
+}
+export function drillWorldPageMatches(value) {
+    const c = value?.continuity;
+    return !!c && Number.isSafeInteger(value.count) && value.count >= 0 && Number.isSafeInteger(value.page) && value.page > 0
+        && Number.isSafeInteger(value.page_size) && value.page_size >= 1 && value.page_size <= 100
+        && Array.isArray(value.results) && value.results.length <= value.page_size
+        && c.scope === 'original_native_world_process' && c.target_clock_controlled === false
+        && [null, 'continuous'].includes(c.mode) && ['not_started', 'running', 'finished', 'interrupted'].includes(c.state)
+        && [c.started_at, c.deadline_at, c.finished_at, c.resource_deadline_at].every(date)
+        && (c.elapsed_ms === null || decimal(c.elapsed_ms)) && !!c.events && typeof c.events === 'object'
+        && (c.preparation_elapsed_ms === null || decimal(c.preparation_elapsed_ms))
+        && ['controller_monotonic', 'service_wall_since_world_ready', 'not_observed'].includes(c.elapsed_basis)
+        && ['active', 'paused', 'canceled'].includes(c.event_state)
+        && (c.revision === null || /^[a-f0-9]{64}$/.test(c.revision)) && decimal(c.applied_watermark)
+        && Number.isSafeInteger(c.control_sequence) && c.control_sequence >= 0 && c.control_sequence <= 100000
+        && typeof c.control_pending === 'boolean'
+        && Object.entries(c.events).every(([key, count]) => ['pending', 'applying', 'applied', 'unmet', 'uncertain', 'canceled'].includes(key) && Number.isSafeInteger(count) && count >= 0)
+        && (c.next_event === null || typeof c.next_event?.key === 'string' && date(c.next_event.due_at))
+        && (c.agent_process === null || !!c.agent_process && ['running', 'exited'].includes(c.agent_process.state)
+            && typeof c.agent_process.source_entry_observed === 'boolean' && [c.agent_process.started_at, c.agent_process.finished_at, c.agent_process.source_entry_observed_at].every(date)
+            && (c.agent_process.exit_code === null || Number.isSafeInteger(c.agent_process.exit_code)))
+        && (c.interaction === null || !!c.interaction && c.interaction.basis === 'original_conversation_input_coordinator'
+            && ['active', 'waiting_for_input', 'closed'].includes(c.interaction.state)
+            && typeof c.interaction.observed_at === 'string' && date(c.interaction.observed_at)
+            && Number.isSafeInteger(c.interaction.sequence) && c.interaction.sequence >= 1 && c.interaction.sequence <= 200001
+            && id(c.interaction.message_stream_id) && [c.interaction.inputs, c.interaction.responses].every(one => Number.isSafeInteger(one) && one >= 0 && one <= 100000)
+            && c.interaction.responses <= c.interaction.inputs && c.interaction.inputs <= c.interaction.responses + 1
+            && (c.interaction.state !== 'active' || c.interaction.inputs === c.interaction.responses + 1)
+            && (c.interaction.state !== 'waiting_for_input' || c.interaction.inputs > 0 && c.interaction.inputs === c.interaction.responses)
+            && (id(c.interaction.request_id) || c.interaction.request_id === null && c.interaction.state === 'closed' && c.interaction.inputs === 0)
+            && (c.interaction.cause_event_key === null || typeof c.interaction.cause_event_key === 'string' && /^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$/.test(c.interaction.cause_event_key))
+            && (c.interaction.state === 'closed' || c.state === 'running'))
+        && value.results.every(one => id(one.id) && typeof one.key === 'string' && /^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$/.test(one.key)
+            && ['record', 'operation', 'ingress', 'message'].includes(one.kind)
+            && Number.isSafeInteger(one.position) && one.position >= 0 && decimal(one.due_after_ms) && decimal(one.watermark)
+            && ['pending', 'applying', 'applied', 'unmet', 'uncertain', 'canceled'].includes(one.state)
+            && [one.due_at, one.intent_observed_at, one.receipt_observed_at].every(date)
+            && [true, false, null].includes(one.condition_observed)
+            && (one.result === null || one.kind !== 'record' && one.state === 'applied' && id(one.result.request_id)
+                && !!one.result.observation && typeof one.result.observation === 'object' && !Array.isArray(one.result.observation)
+                && Object.keys(one.result.observation).length <= 8
+                && (one.result.evidence_id === null && one.result.download_path === null || id(one.result.evidence_id)
+                    && typeof one.result.download_path === 'string'
+                    && /^\/api\/workspaces\/[a-f0-9-]{36}\/campaigns\/[a-f0-9-]{36}\/trials\/[a-f0-9-]{36}\/evidence\/[a-f0-9-]{36}\/bytes$/.test(one.result.download_path))));
+}