firedrill-run 2.2.4 → 3.0.0

package/dist/contracts/resource-lifecycle-contracts.js

@@ -0,0 +1,57 @@
+const object = (value) => !!value && typeof value === 'object' && !Array.isArray(value);
+const uuid = (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 integer = (value) => typeof value === 'number' && Number.isSafeInteger(value) && value >= 0;
+const date = (value) => typeof value === 'string' && Number.isFinite(Date.parse(value));
+const kinds = (value) => value === 'agents' || value === 'worlds';
+const canonicalBody = (value) => JSON.stringify([value.kind, value.id, value.action, value.basis, value.confirm_name, value.retain_saved_data]);
+export function resourceLifecycleBodyMatches(value) {
+    return object(value) && Object.keys(value).sort().join(',') === 'action,basis,confirm_name,id,kind,retain_saved_data'
+        && kinds(value.kind) && uuid(value.id) && ['archive', 'restore', 'remove'].includes(String(value.action))
+        && integer(value.basis) && value.basis > 0 && value.basis < Number.MAX_SAFE_INTEGER
+        && typeof value.confirm_name === 'string' && value.confirm_name.length <= 120 && value.retain_saved_data === true;
+}
+export function resourceLifecycleMetadataMatches(value, selected) {
+    return !!value && value.actor_id === selected.actor && value.workspace_id === selected.workspace
+        && value.id === selected.id && uuid(value.id) && value.kind === selected.kind && kinds(value.kind)
+        && typeof value.name === 'string' && value.name.length <= 120 && integer(value.revision) && value.revision > 0
+        && (value.archived_at === null || date(value.archived_at)) && typeof value.removed === 'boolean'
+        && typeof value.can_write === 'boolean' && typeof value.can_remove === 'boolean';
+}
+/** Whole original receipt, never just a returned record ID or current visibility.
+ * An absent receipt does not cancel an in-flight action; withdrawal is distinct. */
+export function resourceLifecycleReceiptMatches(value, selected, original) {
+    if (!value || value.schema !== 'firedrill.resource-lifecycle.v1' || value.actor_id !== selected.actor
+        || value.workspace_id !== selected.workspace || value.request_key !== original.key || !uuid(value.request_key))
+        return false;
+    if (value.state === 'not_received')
+        return value.body === null && value.result === null && value.created_at === null;
+    if (!date(value.created_at))
+        return false;
+    if (value.state === 'withdrawn')
+        return value.body === null && value.result === null;
+    if (value.state !== 'accepted' || !resourceLifecycleBodyMatches(value.body) || !value.result
+        || original.kind !== undefined && value.body.kind !== original.kind
+        || original.body !== undefined && canonicalBody(value.body) !== canonicalBody(original.body))
+        return false;
+    const body = value.body, result = value.result;
+    return result.id === body.id && result.kind === body.kind && result.name === body.confirm_name
+        && integer(result.revision) && result.revision === body.basis + 1 && result.removed === (body.action === 'remove')
+        && (body.action === 'restore' ? result.archived_at === null : date(result.archived_at));
+}
+export function resourceLifecycleReceiptSame(left, right) {
+    const immutable = (value) => JSON.stringify([value.schema, value.workspace_id, value.actor_id,
+        value.request_key, value.state, value.body === null ? null : canonicalBody(value.body), value.result === null ? null
+            : [value.result.kind, value.result.id, value.result.name, value.result.revision, value.result.archived_at, value.result.removed], value.created_at]);
+    return immutable(left) === immutable(right);
+}
+export function resourceLifecyclePageMatches(value, selected, requested) {
+    return !!value && value.actor_id === selected.actor && value.workspace_id === selected.workspace
+        && value.kind === requested.kind && value.query === requested.query.trim() && value.state === requested.state
+        && integer(value.count) && integer(value.page) && value.page === requested.page
+        && integer(value.page_size) && value.page_size > 0 && value.page_size <= 100 && Array.isArray(value.results)
+        && value.results.length <= value.page_size && value.results.length <= value.count
+        && (value.next === null || typeof value.next === 'string') && (value.previous === null || typeof value.previous === 'string')
+        && value.results.every(row => !!row && row.state !== 'not_received' && (!requested.state || row.state === requested.state)
+            && resourceLifecycleReceiptMatches(row, selected, { key: row.request_key,
+                ...(kinds(requested.kind) ? { kind: requested.kind } : {}) }));
+}

package/dist/contracts/revision-contracts.js

@@ -0,0 +1,12 @@
+export function memoryProbeMatches(a, b) {
+    const points = (probe) => {
+        if (probe.checkpoint)
+            return [probe.exposures, probe.checkpoint];
+        return [probe.exposure_turns.map(turn => ({ kind: 'turn', turn })), { kind: 'turn', turn: probe.checkpoint_turn }];
+    };
+    const same = (x, y) => x.kind === y.kind && (x.kind === 'turn'
+        ? y.kind === 'turn' && x.turn === y.turn : y.kind === 'world_event' && x.event_key === y.event_key);
+    const [ax, ac] = points(a), [bx, bc] = points(b);
+    return a.key === b.key && a.kind === b.kind && a.expectation === b.expectation && same(ac, bc)
+        && ax.length === bx.length && ax.every((point, index) => same(point, bx[index]));
+}

package/dist/contracts/revision-request-contracts.js

@@ -0,0 +1,39 @@
+const uuid = (value) => typeof value === 'string' && /^[a-f0-9]{8}(?:-[a-f0-9]{4}){3}-[a-f0-9]{12}$/.test(value);
+export function revisionRequestMatches(value, scope, key) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    const row = value;
+    return row.schema === 'firedrill.revision-request-receipt.v1' && row.kind === scope.kind
+        && row.actor_id === scope.actor && row.workspace_id === scope.workspace && row.world_id === scope.world
+        && row.parent_id === scope.parent && uuid(row.request_key) && row.request_key === key
+        && (row.state === 'not_received' ? row.resource_available === false && row.resource_id === null && row.created_at === null
+            : ['accepted', 'unavailable'].includes(row.state) && typeof row.created_at === 'string' && Number.isFinite(Date.parse(row.created_at))
+                && (row.state === 'accepted' ? row.resource_available === true && uuid(row.resource_id)
+                    : row.resource_available === false && row.resource_id === null));
+}
+export function revisionRequestPath(scope, key) {
+    return `/${scope.kind === 'scenario_draft' ? 'scenario-drafts' : 'execution-proposals'}/${scope.parent}/requests/${key}`;
+}
+/** Stable request comparison only. The returned private text must never be persisted or logged. */
+export function revisionRequestCanonical(body) {
+    if (new TextEncoder().encode(body).length > 512 * 1024)
+        throw new Error('The revision exceeds the supported request size.');
+    const value = JSON.parse(body);
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        throw new Error('Use a revision request object.');
+    let count = 0;
+    function encode(one, depth) {
+        if (depth > 64 || ++count > 100000)
+            throw new Error('The revision exceeds the supported request complexity.');
+        if (Array.isArray(one))
+            return '[' + one.map(item => encode(item, depth + 1)).join(',') + ']';
+        if (one && typeof one === 'object')
+            return '{' + Object.keys(one).sort().map(key => JSON.stringify(key) + ':'
+                + encode(one[key], depth + 1)).join(',') + '}';
+        const encoded = JSON.stringify(one);
+        if (encoded === undefined)
+            throw new Error('Use a complete revision request.');
+        return encoded;
+    }
+    return encode(value, 0);
+}

package/dist/contracts/saved-record-contracts.js

@@ -0,0 +1,76 @@
+const uuid = /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/;
+const hash = /^[a-f0-9]{64}$/;
+const count = (value) => Number.isSafeInteger(value) && value >= 0;
+const timestamp = (value) => typeof value === 'string' && Number.isFinite(Date.parse(value));
+export function savedRecordSelection(prefix, workspace, observation) {
+    const parts = prefix.split('/');
+    if (!uuid.test(workspace) || !uuid.test(observation) || parts[0] !== '' || parts[1] !== 'api'
+        || parts[2] !== 'workspaces' || parts[3] !== workspace)
+        return null;
+    const base = { workspace_id: workspace, observation_id: observation, world_id: null, session_id: null, instance_id: null };
+    if (parts[4] === 'worlds' && uuid.test(parts[5] ?? '')) {
+        if (parts.length === 6)
+            return { ...base, world_id: parts[5], scope: 'starting_data' };
+        if (parts.length === 10 && parts[6] === 'runtime-sessions' && uuid.test(parts[7] ?? '') && parts[8] === 'observations'
+            && parts[9] === observation)
+            return { ...base, world_id: parts[5], session_id: parts[7], scope: 'session_sql' };
+    }
+    return parts.length === 9 && parts[4] === 'tools' && parts[5] === 'instances' && uuid.test(parts[6] ?? '')
+        && parts[7] === 'checkpoints' && parts[8] === observation ? { ...base, instance_id: parts[6], scope: 'tool_checkpoint' } : null;
+}
+export function savedRecordSelectionMatches(value, selected) {
+    return !!value && !!selected && value.workspace_id === selected.workspace_id && value.world_id === selected.world_id
+        && value.session_id === selected.session_id && value.instance_id === selected.instance_id
+        && value.observation_id === selected.observation_id && value.scope === selected.scope;
+}
+function headerMatches(value) {
+    return !!value && hash.test(value.key) && typeof value.name === 'string' && value.name.length > 0
+        && (value.store === null || typeof value.store === 'string') && count(value.row_count) && timestamp(value.observed_at)
+        && (value.column_count === null || count(value.column_count)) && value.schema_included === false;
+}
+export function savedCollectionMatches(value, key) {
+    return !!value && hash.test(value.key) && value.key === key && !!value.name && count(value.row_count) && timestamp(value.observed_at)
+        && (value.store === undefined || value.store === null || typeof value.store === 'string') && Array.isArray(value.columns)
+        && value.columns.every(one => !!one.name && typeof one.type === 'string' && typeof one.nullable === 'boolean')
+        && Array.isArray(value.primary_key) && value.primary_key.every(name => value.columns.some(one => one.name === name));
+}
+export function savedCollectionsPageMatches(value, selected, query = '') {
+    return !!value && savedRecordSelectionMatches(value.selection, selected) && value.query === query.trim()
+        && (value.observation === undefined || value.observation.id === selected.observation_id && value.observation.scope === selected.scope)
+        && (value.checkpoint === undefined || value.checkpoint.id === selected.observation_id && selected.scope === 'tool_checkpoint')
+        && value.results.every(headerMatches);
+}
+export function savedCollectionDetailMatches(value, selected, key) {
+    return !!value && savedRecordSelectionMatches(value.selection, selected) && savedCollectionMatches(value, key);
+}
+export function savedStateCellMatches(value, depth = 0) {
+    if (!value || depth > 24)
+        return false;
+    if (value.type === 'null' || value.type === 'redacted')
+        return true;
+    if (value.type === 'boolean')
+        return typeof value.value === 'boolean';
+    if (value.type === 'float')
+        return typeof value.value === 'number' ? Number.isFinite(value.value) : ['nan', 'inf', '-inf'].includes(value.value);
+    if (value.type === 'array')
+        return 'value' in value ? Array.isArray(value.value) && value.value.every(one => savedStateCellMatches(one, depth + 1)) : count(value.size);
+    if (value.type === 'object')
+        return 'value' in value ? !!value.value && typeof value.value === 'object' && !Array.isArray(value.value)
+            && Object.values(value.value).every(one => savedStateCellMatches(one, depth + 1)) : count(value.size);
+    if (value.type === 'binary')
+        return !('value' in value) || value.encoding === 'base64' && typeof value.value === 'string';
+    return ['string', 'integer', 'decimal', 'datetime', 'date', 'time', 'uuid'].includes(value.type) && typeof value.value === 'string';
+}
+function rowMatches(value) {
+    return !!value && count(value.position) && !!value.values && typeof value.values === 'object' && !Array.isArray(value.values)
+        && Object.values(value.values).every(one => savedStateCellMatches(one));
+}
+export function savedRecordsPageMatches(value, selected, key, query = '') {
+    return !!value && savedRecordSelectionMatches(value.selection, selected) && value.query === query.trim()
+        && savedCollectionMatches(value.collection, key) && value.results.every(rowMatches);
+}
+export function savedRecordDetailMatches(value, selected, key, position) {
+    return !!value && savedRecordSelectionMatches(value.selection, selected) && value.scope === selected.scope
+        && (value.checkpoint_id === undefined || selected.scope === 'tool_checkpoint' && value.checkpoint_id === selected.observation_id)
+        && savedCollectionMatches(value.collection, key) && value.position === position && rowMatches(value);
+}

package/dist/contracts/scenario-draft-comparison.js

@@ -0,0 +1,91 @@
+const id = (value) => typeof value === 'string' && /^[a-f0-9]{8}(?:-[a-f0-9]{4}){3}-[a-f0-9]{12}$/.test(value);
+const record = (value) => Boolean(value && typeof value === 'object' && !Array.isArray(value));
+const integer = (value) => typeof value === 'number' && Number.isSafeInteger(value) && value >= 1;
+const hash = (value) => typeof value === 'string' && /^[a-f0-9]{64}$/.test(value);
+const owns = (value, key) => Object.prototype.hasOwnProperty.call(value, key);
+const MAX_BYTES = 768 * 1024; // Existing 512KiB definition plus bounded grounding/metadata.
+const DISPLAY_CHARACTERS = 2048;
+const labels = { instruction: 'Task', setup_code: 'Starting state setup', ready_code: 'Readiness check',
+    fixture: 'Initial data and events', persona: 'Synthetic user', sub_goals: 'Required checks', max_turns: 'Turn limit',
+    variables: 'Variables', coverage: 'Coverage links', use_case: 'Use case', branch: 'Branch' };
+function canonical(value) {
+    let nodes = 0;
+    const seen = new WeakSet();
+    function visit(one, depth) {
+        if (++nodes > 50000 || depth > 28)
+            throw new Error('comparison_capacity');
+        if (one === null || typeof one === 'string' || typeof one === 'boolean')
+            return one;
+        if (typeof one === 'number' && Number.isFinite(one))
+            return one;
+        if (!one || typeof one !== 'object' || seen.has(one))
+            throw new Error('comparison_value');
+        seen.add(one);
+        if (Array.isArray(one))
+            return one.map(value => visit(value, depth + 1));
+        if (Object.getPrototypeOf(one) !== Object.prototype && Object.getPrototypeOf(one) !== null)
+            throw new Error('comparison_value');
+        const result = Object.create(null);
+        for (const key of Object.keys(one).sort())
+            result[key] = visit(one[key], depth + 1);
+        return result;
+    }
+    const result = JSON.stringify(visit(value, 0));
+    if (typeof result !== 'string' || new TextEncoder().encode(result).byteLength > MAX_BYTES)
+        throw new Error('comparison_capacity');
+    return result;
+}
+export function scenarioDraftReviewMatches(value, expectedId) {
+    if (!record(value) || value.schema !== 'firedrill.scenario-draft.v1' || !id(value.id)
+        || expectedId !== undefined && value.id !== expectedId || !(value.parent_id === null || id(value.parent_id) && value.parent_id !== value.id)
+        || !id(value.actor_id) || !id(value.source_id) || !integer(value.world_revision) || !integer(value.configuration_revision)
+        || !hash(value.fingerprint) || !record(value.draft))
+        return false;
+    const draft = value.draft;
+    if (Object.keys(draft).some(key => !['title', 'definition', 'grounds', 'family', 'variation', 'unresolved'].includes(key))
+        || typeof draft.title !== 'string' || !draft.title.trim() || draft.title.length > 255 || !record(draft.definition)
+        || Object.keys(draft.definition).length > 64 || !Array.isArray(draft.grounds) || draft.grounds.length < 1 || draft.grounds.length > 24
+        || !draft.grounds.every(record) || ['family', 'variation'].some(key => owns(draft, key) && (typeof draft[key] !== 'string' || draft[key].length > 255))
+        || owns(draft, 'unresolved') && (!Array.isArray(draft.unresolved) || draft.unresolved.length > 24
+            || !draft.unresolved.every(one => typeof one === 'string' && one.length <= 1000)))
+        return false;
+    try {
+        canonical(draft);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function sameScenarioDraft(left, right) {
+    if (!scenarioDraftReviewMatches(left) || !scenarioDraftReviewMatches(right))
+        return false;
+    return left.id === right.id && left.parent_id === right.parent_id && left.actor_id === right.actor_id && left.source_id === right.source_id
+        && left.world_revision === right.world_revision && left.configuration_revision === right.configuration_revision
+        && left.fingerprint === right.fingerprint && canonical(left.draft) === canonical(right.draft);
+}
+function presentation(value, present) {
+    if (!present)
+        return { present: false, text: 'Not present', truncated: false, characters: 0 };
+    const text = typeof value === 'string' ? value : canonical(value);
+    return { present: true, text: text.slice(0, DISPLAY_CHARACTERS), truncated: text.length > DISPLAY_CHARACTERS, characters: text.length };
+}
+export function compareScenarioDrafts(parent, child) {
+    if (!scenarioDraftReviewMatches(child) || !scenarioDraftReviewMatches(parent, child.parent_id ?? '')
+        || child.actor_id !== parent.actor_id || child.source_id !== parent.source_id
+        || child.world_revision !== parent.world_revision || child.configuration_revision !== parent.configuration_revision)
+        return null;
+    const differences = [];
+    function compare(field, title, before, after, key) {
+        const wasPresent = owns(before, key), isPresent = owns(after, key);
+        if (wasPresent === isPresent && (!wasPresent || canonical(before[key]) === canonical(after[key])))
+            return;
+        differences.push({ field, label: title, before: presentation(before[key], wasPresent), after: presentation(after[key], isPresent) });
+    }
+    for (const name of ['title', 'family', 'variation', 'grounds', 'unresolved'])
+        compare(name, { title: 'Name', family: 'Family', variation: 'Variation', grounds: 'Source grounding', unresolved: 'Unresolved choices' }[name], parent.draft, child.draft, name);
+    for (const name of [...new Set([...Object.keys(parent.draft.definition), ...Object.keys(child.draft.definition)])].sort())
+        compare('definition.' + name, labels[name] ?? name.replaceAll('_', ' '), parent.draft.definition, child.draft.definition, name);
+    return { parent_id: parent.id, draft_id: child.id, parent_fingerprint: parent.fingerprint,
+        draft_fingerprint: child.fingerprint, differences };
+}

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

@@ -0,0 +1,14 @@
+export function scenarioWorldEventsMatch(value, definition) {
+    const count = (one, min = 0) => typeof one === 'number' && Number.isSafeInteger(one) && one >= min;
+    const name = (one) => typeof one === 'string' && /^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$/.test(one);
+    return !!value && value.definition_digest === definition && /^[a-f0-9]{64}$/.test(definition)
+        && count(value.count) && count(value.page, 1) && count(value.page_size, 1) && value.page_size <= 100
+        && Array.isArray(value.results) && value.results.length <= value.page_size && new Set(value.results.map(one => one.id)).size === value.results.length
+        && value.results.every(one => name(one.id) && ['record', 'operation', 'ingress', 'message'].includes(one.kind)
+            && typeof one.after_ms === 'string' && /^(0|[1-9][0-9]{0,9})$/.test(one.after_ms)
+            && Array.isArray(one.depends_on) && one.depends_on.length <= 100 && one.depends_on.every(name)
+            && (one.repeat === null || !!one.repeat && count(one.repeat.count, 1) && one.repeat.count <= 10000 && count(one.repeat.interval_ms, 1))
+            && [one.collection, one.action, one.variable, one.operation, one.method, one.path, one.tool, one.text_preview]
+                .every(child => child === null || typeof child === 'string')
+            && [null, 'http', 'mcp'].includes(one.protocol) && typeof one.conditional === 'boolean' && typeof one.text_shortened === 'boolean');
+}

package/dist/contracts/service-contracts.js

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

package/dist/contracts/session-command-contracts.js

@@ -0,0 +1,56 @@
+const uuid = /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/;
+const states = new Set(['publishing', 'queued', 'accepted', 'observed', 'not_dispatched', 'unknown', 'stop_requested']);
+const sequence = /^(?:0|[1-9][0-9]{0,18})$/;
+const key = /^[A-Za-z0-9._:-]{8,128}$/;
+export function callableOperationMatches(value) {
+    return !!value && !!value.name && value.name.length <= 255 && typeof value.route === 'string'
+        && value.route.startsWith('/') && !value.route.startsWith('//')
+        && (value.protocol === 'http' ? ['GET', 'HEAD', 'POST', 'PUT', 'PATCH', 'DELETE', 'OPTIONS'].includes(value.method ?? '')
+            : value.protocol === 'mcp' && value.method === 'POST' && typeof value.mcp_tool === 'string' && value.mcp_tool.length > 0 && value.mcp_tool.length <= 128);
+}
+export function callableOperationsPageMatches(value, service, protocol) {
+    return !!value && value.coverage.id === service && value.results.every(row => callableOperationMatches(row) && (!protocol || row.protocol === protocol));
+}
+function scopeMatches(value, scope) {
+    return value.workspace_id === scope.workspace && value.world_id === scope.world && value.session_id === scope.session;
+}
+export function sessionCommandMatches(value, scope, selected) {
+    if (!value || !scopeMatches(value, scope) || !uuid.test(value.id) || !uuid.test(value.actor_id) || !uuid.test(value.service_id)
+        || !key.test(value.request_key) || !states.has(value.state) || !['http', 'mcp'].includes(value.protocol)
+        || !sequence.test(value.sequence) || value.sequence === '0' || BigInt(value.sequence) > 9223372036854775807n
+        || value.reset_count !== null && (!sequence.test(value.reset_count) || BigInt(value.reset_count) > 9223372036854775807n)
+        || value.origin !== (value.protocol === 'mcp' ? 'manual_session_mcp' : 'manual_session_http')
+        || !Number.isSafeInteger(value.request_bytes) || value.request_bytes < 0 || value.request_bytes > 8 * 1024 ** 2
+        || selected?.id && value.id !== selected.id || selected?.key && (value.request_key !== selected.key || value.actor_id !== scope.actor)
+        || selected?.service && value.service_id !== selected.service || selected?.operation && value.operation !== selected.operation
+        || selected?.variable && value.variable !== selected.variable || selected?.protocol && value.protocol !== selected.protocol)
+        return false;
+    const response = value.response;
+    if (!response)
+        return true;
+    if (value.state !== 'observed' || !Number.isSafeInteger(response.body_size) || response.body_size < 0 || response.body_size > 16 * 1024 ** 2)
+        return false;
+    return value.protocol === 'mcp' ? response.http_status === null && typeof response.mcp_is_error === 'boolean'
+        && ['matched', 'mismatch', 'missing_structured', 'not_declared'].includes(response.schema_status ?? '')
+        : Number.isInteger(response.http_status) && response.http_status >= 100 && response.http_status <= 599
+            && response.mcp_is_error === null && response.schema_status === null;
+}
+export function sessionCommandsPageMatches(value, scope, query = '', service = null) {
+    return !!value && scopeMatches(value, scope) && value.query === query.trim() && value.service_filter === service
+        && value.results.every(row => sessionCommandMatches(row, scope, service ? { service } : undefined));
+}
+export function sessionCommandRequestMatches(value, scope, original) {
+    return !!value && scopeMatches(value, scope) && value.actor_id === scope.actor && value.request_key === original
+        && (value.state === 'not_observed' ? value.request === null
+            : value.state === 'observed' && !!value.request && sessionCommandMatches(value.request, scope, { key: original }));
+}
+export function sessionConnectionsPageMatches(value, scope, selected) {
+    return !!value && scopeMatches(value, scope) && value.query === (selected?.query ?? '').trim()
+        && value.service_filter === (selected?.service ?? null) && value.protocol_filter === (selected?.protocol ?? null)
+        && value.variable_filter === (selected?.variable ?? null) && value.callable_only === (selected?.callable ?? false)
+        && value.results.every(row => uuid.test(row.service_id) && /^[A-Za-z_][A-Za-z0-9_]{0,127}$/.test(row.variable)
+            && ['http', 'mcp', 'postgres', 'redis', 'amqp'].includes(row.protocol)
+            && (!value.callable_only || ['http', 'mcp'].includes(row.protocol))
+            && (!value.service_filter || row.service_id === value.service_filter) && (!value.protocol_filter || row.protocol === value.protocol_filter)
+            && (!value.variable_filter || row.variable === value.variable_filter));
+}

package/dist/contracts/session-contracts.js

@@ -0,0 +1,65 @@
+const uuid = /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/;
+const key = /^[A-Za-z0-9._:-]{8,128}$/;
+const states = new Set(['queued', 'starting', 'active', 'closing', 'reconciling', 'stopped', 'failed', 'canceled']);
+const terminal = new Set(['stopped', 'failed', 'canceled']);
+export function worldSessionOpeningScopeMatches(value) {
+    return !!value && uuid.test(value.source_id) && typeof value.source_revision === 'string' && value.source_revision.length > 0
+        && value.source_revision.length <= 256 && Number.isSafeInteger(value.world_revision) && value.world_revision > 0
+        && Number.isSafeInteger(value.configuration_revision) && value.configuration_revision >= 0
+        && Number.isSafeInteger(value.duration_seconds) && value.duration_seconds >= 1 && value.duration_seconds <= 2147483647
+        && Number.isSafeInteger(value.max_duration_seconds) && value.max_duration_seconds >= value.duration_seconds
+        && value.max_duration_seconds <= 2147483647 && Number.isSafeInteger(value.real_connections_count) && value.real_connections_count >= 0;
+}
+export function worldSessionMatches(value, scope, selected) {
+    if (!value || !uuid.test(value.id) || value.workspace_id !== scope.workspace || value.world_id !== scope.world
+        || !uuid.test(value.source_id) || !uuid.test(value.actor_id) || !key.test(value.request_key) || !states.has(value.state)
+        || selected?.id && value.id !== selected.id || selected?.key && (value.request_key !== selected.key || value.actor_id !== scope.actor)
+        || !['managed', 'local'].includes(value.execution_location)
+        || value.provenance !== (value.execution_location === 'local' ? 'customer_device' : 'managed_execution')
+        || Boolean(value.terminal_at) !== terminal.has(value.state) || !/^[0-9]+$/.test(value.reset_count)
+        || value.local_execution && (value.execution_location !== 'local' || value.actor_id !== scope.actor
+            || !uuid.test(value.local_execution.job_id) || !uuid.test(value.local_execution.grant_id) || !uuid.test(value.local_execution.device_key))
+        || value.external_effects && (value.external_effects.external_reset_supported !== false || value.external_effects.automatic_target_retry !== false
+            || !Number.isSafeInteger(value.external_effects.real_connections_count) || value.external_effects.real_connections_count < 1)
+        || value.starting_data && value.starting_data.dataset_id !== value.dataset_id)
+        return false;
+    if (!value.coordinated_checkpoint || typeof value.coordinated_checkpoint.available !== 'boolean'
+        || value.coordinated_checkpoint.available && (!value.application_checkpoint?.available || !value.checkpoints_available || value.external_effects !== null))
+        return false;
+    const application = value.application_checkpoint;
+    if (!application || typeof application.available !== 'boolean' || !Array.isArray(application.components) || application.components.length > 1000
+        || application.components.some(one => !one || typeof one.name !== 'string' || one.name.length < 1
+            || !['application_memory', 'database', 'files', 'queue_cursor', 'conversation', 'scheduled_jobs'].includes(one.kind)
+            || !['application_consistent', 'crash_consistent'].includes(one.consistency))
+        || !Array.isArray(application.excluded) || application.excluded.length > 1000
+        || application.excluded.some(one => typeof one !== 'string' || one.length < 1 || one.length > 256)
+        || application.available && (!application.components.length || !application.excluded.length))
+        return false;
+    const body = selected?.body;
+    if (!body)
+        return true;
+    return value.actor_id === scope.actor && value.world_revision === body.world_revision
+        && value.configuration_revision === body.configuration_revision && (!body.source_id || value.source_id === body.source_id)
+        && (!body.source_revision || value.source_revision === body.source_revision)
+        && value.dataset_id === (body.dataset_id ?? null) && (value.fork?.checkpoint_id ?? null) === (body.checkpoint_id ?? null)
+        && value.execution_location === (body.execution?.location ?? 'managed')
+        && value.usage_quote_id === (body.usage_quote_id ?? null)
+        && value.application_checkpoint_id === (body.application_checkpoint_id ?? null)
+        && (body.execution?.location !== 'local' || value.local_execution?.grant_id === body.execution.grant_id)
+        && Boolean(value.external_effects) === Boolean(body.real_account_consent);
+}
+export function worldSessionsPageMatches(value, scope, filter = '') {
+    return !!value && value.workspace_id === scope.workspace && value.world_id === scope.world && value.state_filter === filter
+        && value.results.every(row => worldSessionMatches(row, scope) && (filter === '' || Boolean(row.terminal_at) === (filter === 'closed')))
+        && (value.opening_scope === null || worldSessionOpeningScopeMatches(value.opening_scope));
+}
+export function worldSessionRequestMatches(value, scope, original, body) {
+    if (!value || value.workspace_id !== scope.workspace || value.world_id !== scope.world || value.actor_id !== scope.actor
+        || value.request_key !== original || !['not_observed', 'pending', 'accepted', 'withdrawn'].includes(value.state)
+        || typeof value.withdrawn !== 'boolean' || value.state === 'withdrawn' && !value.withdrawn)
+        return false;
+    if (!('session' in value))
+        return value.withdrawn === true;
+    return value.state === 'accepted' ? !!value.session && worldSessionMatches(value.session, scope, { key: original, body })
+        : value.session === null && (value.state === 'withdrawn' || !value.withdrawn);
+}

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

@@ -0,0 +1,67 @@
+const uuid = /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/;
+const states = new Set(['publishing', 'queued', 'accepted', 'observed', 'not_dispatched', 'unknown', 'stop_requested']);
+export function sessionStateCounter(value) {
+    if (typeof value !== 'string' || !/^(0|[1-9][0-9]{0,18})$/.test(value))
+        return null;
+    const parsed = BigInt(value);
+    return parsed <= 9223372036854775807n ? parsed : null;
+}
+function scopeMatches(value, scope) {
+    return value.workspace_id === scope.workspace && value.world_id === scope.world && value.session_id === scope.session;
+}
+export function sessionStateActionMatches(value, scope, kind, selected) {
+    if (!value || !scopeMatches(value, scope) || !uuid.test(value.id) || !uuid.test(value.actor_id)
+        || !/^[A-Za-z0-9._:-]{8,128}$/.test(value.request_key) || !states.has(value.state)
+        || sessionStateCounter(value.sequence) === null || value.sequence === '0'
+        || selected?.id && value.id !== selected.id || selected?.key && (value.request_key !== selected.key || value.actor_id !== scope.actor))
+        return false;
+    if (kind === 'capture') {
+        if (!('observation' in value) || value.scope !== 'session_sql' || value.reset_count !== null && sessionStateCounter(value.reset_count) === null)
+            return false;
+        const observed = value.observation;
+        return (!selected?.counter || value.reset_count === selected.counter) && (!observed || value.state === 'observed'
+            && uuid.test(observed.id) && Number.isSafeInteger(observed.collection_count) && observed.collection_count >= 0
+            && Number.isSafeInteger(observed.record_count) && observed.record_count >= 0);
+    }
+    if (!('expected_reset_count' in value) || value.expected_reset_count !== null && sessionStateCounter(value.expected_reset_count) === null
+        || selected?.counter && value.expected_reset_count !== selected.counter)
+        return false;
+    if (kind === 'reset') {
+        if (!('reset_at' in value) || value.reset_count !== null && sessionStateCounter(value.reset_count) === null)
+            return false;
+        return value.reset_at === null ? value.reset_count === null : value.state === 'observed' && value.reset_count !== null
+            && (value.expected_reset_count === null || sessionStateCounter(value.reset_count) === sessionStateCounter(value.expected_reset_count) + 1n);
+    }
+    return 'kind' in value && value.kind === kind && (!selected?.checkpoint || value.checkpoint_id === selected.checkpoint)
+        && (value.checkpoint_id === null || uuid.test(value.checkpoint_id))
+        && (kind === 'save' ? value.checkpoint_id === value.id && value.restored_at === null
+            && value.checkpoint_available !== null && (!value.checkpoint_available || value.captured && value.state === 'observed')
+            : value.checkpoint_available === null && !value.captured && (value.restored_at === null || value.state === 'observed'));
+}
+export function sessionStateRequestMatches(value, scope, key, kind, selected) {
+    return !!value && scopeMatches(value, scope) && value.actor_id === scope.actor && value.request_key === key
+        && (value.state === 'not_observed' ? value.request === null : value.state === 'observed' && !!value.request
+            && sessionStateActionMatches(value.request, scope, kind, { ...selected, key }));
+}
+export function sessionCapturesPageMatches(value, scope) {
+    return !!value && scopeMatches(value, scope) && value.results.every(row => sessionStateActionMatches(row, scope, 'capture'));
+}
+export function sessionResetsPageMatches(value, scope) {
+    return !!value && scopeMatches(value, scope) && value.results.every(row => sessionStateActionMatches(row, scope, 'reset'));
+}
+export function sessionCheckpointActionsPageMatches(value, scope, query = '') {
+    return !!value && scopeMatches(value, scope) && value.query === query.trim()
+        && value.results.every(row => sessionStateActionMatches(row, scope, row.kind));
+}
+export function worldCheckpointMatches(value, scope) {
+    return !!value && uuid.test(value.id) && value.workspace_id === scope.workspace && value.world_id === scope.world
+        && uuid.test(value.session_id) && uuid.test(value.source_id) && uuid.test(value.configuration_id) && uuid.test(value.actor_id)
+        && /^[A-Za-z0-9._:-]{8,128}$/.test(value.request_key) && ['pending', 'retained', 'unavailable'].includes(value.state)
+        && (value.record_count === null || Number.isSafeInteger(value.record_count) && value.record_count >= 0)
+        && (value.collection_count === null || Number.isSafeInteger(value.collection_count) && value.collection_count >= 0)
+        && (!value.available || value.state === 'retained' && value.scope !== null) && (!value.compatible || value.available);
+}
+export function sessionCheckpointsPageMatches(value, scope, query = '', checkpoint = null) {
+    return !!value && scopeMatches(value, scope) && value.query === query.trim() && value.checkpoint_filter === checkpoint
+        && value.results.every(row => worldCheckpointMatches(row, scope) && (!checkpoint || row.id === checkpoint));
+}

package/dist/contracts/session-voice-contracts.js

@@ -0,0 +1,45 @@
+import { sessionStateCounter } from './session-state-contracts.js';
+const uuid = /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/;
+const states = new Set(['publishing', 'queued', 'accepted', 'observed', 'not_dispatched', 'unknown', 'stop_requested']);
+function scoped(value, scope) {
+    return value.workspace_id === scope.workspace && value.world_id === scope.world && value.session_id === scope.session;
+}
+export function manualVoiceTurnMatches(value, scope, selected) {
+    if (!value || !scoped(value, scope) || !uuid.test(value.id) || !uuid.test(value.actor_id) || !uuid.test(value.call_id)
+        || !/^[A-Za-z0-9._:-]{8,128}$/.test(value.request_key) || !states.has(value.state)
+        || !['voice_start', 'voice_audio', 'voice_listen', 'voice_stop'].includes(value.kind)
+        || sessionStateCounter(value.sequence) === null || value.sequence === '0'
+        || value.expected_reset_count !== null && sessionStateCounter(value.expected_reset_count) === null
+        || selected?.id && value.id !== selected.id || selected?.key && (value.request_key !== selected.key || value.actor_id !== scope.actor)
+        || value.kind === 'voice_start' && value.call_id !== value.id)
+        return false;
+    const input = selected?.input;
+    if (input && (value.kind !== input.kind || value.expected_reset_count !== input.expected_reset_count || value.record_audio !== input.record_audio
+        || value.call_id !== (input.kind === 'voice_start' ? value.id : input.call_id)))
+        return false;
+    const counts = [value.input_samples, value.received_samples, value.omitted_samples];
+    if (counts.some(one => one !== null && (!Number.isSafeInteger(one) || one < 0))
+        || value.input_samples !== null && value.input_samples > 48000 * 30
+        || value.audio_available !== !!value.audio || value.audio && value.state !== 'observed'
+        || value.input_audio_available && (value.kind !== 'voice_audio' || value.state !== 'observed' || !value.record_audio)
+        || value.audio_expires_at !== null && !value.audio_available)
+        return false;
+    const audio = value.audio;
+    return !audio || audio.sample_rate === 48000 && audio.channels === 1 && audio.sample_width === 2
+        && Number.isSafeInteger(audio.samples) && audio.samples > 0 && audio.samples <= 48000 * 30
+        && audio.size > 44 && audio.size <= 48000 * 30 * 2 + 44 && Number.isSafeInteger(audio.size)
+        && /^[a-f0-9]{64}$/.test(audio.sha256) && audio.duration_ms === Math.floor(audio.samples * 1000 / 48000)
+        && value.received_samples !== null && audio.samples <= value.received_samples && value.audio_recorded;
+}
+export function manualVoicePageMatches(value, scope, call = null) {
+    if (!value || !scoped(value, scope) || value.call_filter !== call
+        || !value.results.every(row => manualVoiceTurnMatches(row, scope) && (!call || row.call_id === call)))
+        return false;
+    return !value.call || uuid.test(value.call.id) && uuid.test(value.call.actor_id)
+        && value.call.owned === (value.call.actor_id === scope.actor) && ['opening', 'open', 'unknown'].includes(value.call.state);
+}
+export function manualVoiceRequestMatches(value, scope, key, input) {
+    return !!value && scoped(value, scope) && value.actor_id === scope.actor && value.request_key === key
+        && (value.state === 'not_observed' ? value.request === null : value.state === 'observed' && !!value.request
+            && manualVoiceTurnMatches(value.request, scope, { key, input }));
+}

package/dist/contracts/source-set-contracts.js

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+const sha = z.string().regex(/^[a-f0-9]{64}$/);
+const root = z.object({ alias: z.string().regex(/^[a-z][a-z0-9_-]{0,63}$/), source_id: z.string().uuid(),
+    revision: z.string(), label: z.string(), directory: z.string() });
+export const sourceSetSchema = z.object({ id: z.string().uuid(), workspace_id: z.string().uuid(), actor_id: z.string().uuid(),
+    agent_id: z.string().uuid(), request_key: z.string().uuid(), request_sha256: sha, source_id: z.string().uuid(), previous_source_id: z.string().uuid(),
+    state: z.enum(['queued', 'assembling', 'ready', 'failed', 'withdrawn']), source_set_sha256: sha, graph_sha256: sha,
+    roots: z.array(root).max(128), graph: z.record(z.string(), z.unknown()), created_at: z.string(), finished_at: z.string().nullable(),
+    failure: z.object({ code: z.string(), message: z.string() }).nullable() });
+export const sourceOptionSchema = z.object({ id: z.string().uuid(), agent_id: z.string().uuid(), name: z.string(),
+    label: z.string(), revision: z.string(), kind: z.string(), root: z.string() });
+export const sourceSetWithdrawalSchema = z.object({ state: z.literal('withdrawn'), request_key: z.string().uuid(),
+    request_sha256: sha, workspace_id: z.string().uuid(), agent_id: z.string().uuid(), actor_id: z.string().uuid() }).strict();
+export function readSourceSetWithdrawal(value, workspace, agent, actor, key, digest) {
+    const parsed = sourceSetWithdrawalSchema.parse(value);
+    if (parsed.workspace_id !== workspace || parsed.agent_id !== agent || parsed.actor_id !== actor || parsed.request_key !== key
+        || digest !== undefined && parsed.request_sha256 !== digest)
+        throw new Error('The withdrawn source selection could not be confirmed.');
+    return parsed;
+}
+export function readSourceSet(value, workspace, agent, key) {
+    const parsed = sourceSetSchema.parse(value);
+    if (parsed.workspace_id !== workspace || parsed.agent_id !== agent || key && parsed.request_key !== key)
+        throw new Error('The source selection changed. Open its latest details.');
+    return parsed;
+}

package/dist/contracts/source-upload-contracts.js

@@ -0,0 +1,22 @@
+const uuid = (value) => typeof value === 'string' && /^[a-f0-9]{8}(?:-[a-f0-9]{4}){3}-[a-f0-9]{12}$/.test(value);
+const headerNames = ['Content-Type', 'x-goog-if-generation-match', 'x-goog-meta-firedrill-source-artifact', 'x-goog-meta-firedrill-source-upload'];
+export function rawSourceUploadMatches(value, workspace, upload) {
+    try {
+        if (!value || !uuid(workspace) || !uuid(value.artifact_id) || !uuid(value.upload_id)
+            || upload !== undefined && value.upload_id !== upload || value.method !== 'PUT' || !value.headers
+            || Object.keys(value.headers).sort().join(',') !== headerNames.join(',')
+            || value.headers['Content-Type'] !== 'application/octet-stream' || value.headers['x-goog-if-generation-match'] !== '0'
+            || value.headers['x-goog-meta-firedrill-source-artifact'] !== value.artifact_id
+            || value.headers['x-goog-meta-firedrill-source-upload'] !== value.upload_id)
+            return false;
+        const target = new URL(value.upload_url), parts = target.pathname.split('/').slice(1).map(decodeURIComponent);
+        return target.origin === 'https://storage.googleapis.com' && !target.username && !target.password && !target.hash
+            && parts.length === 6 && !!parts[0] && parts[1] === 'private' && uuid(parts[2]) && parts[3] === workspace
+            && parts[4] === 'source' && uuid(parts[5])
+            && target.searchParams.getAll('X-Goog-SignedHeaders').length === 1
+            && target.searchParams.get('X-Goog-SignedHeaders') === ['content-type', 'host', ...headerNames.slice(1)].join(';');
+    }
+    catch {
+        return false;
+    }
+}