@timurproko/a1 0.1.8-dev.49ff83a → 0.1.8-dev.508

package/dist/src/foundation/workspace-contracts/validation.js

@@ -1,335 +0,0 @@
-import { NATIVE_HOST_PROTOCOL_VERSION, WORKSPACE_CONTRACT_VERSION } from "./model.js";
-const MAX_ID_LENGTH = 128;
-const MAX_LABEL_LENGTH = 256;
-const MAX_COLLECTION_LENGTH = 10_000;
-const MAX_ENVIRONMENT_ENTRIES = 512;
-const MAX_ARGUMENTS = 1_024;
-const MAX_POSITION = Number.MAX_SAFE_INTEGER;
-const MAX_LIMIT = 1_000_000_000;
-export function assertManagedAgentDescriptor(agent) {
-    assertId(agent.id, "agent id");
-    assertText(agent.displayName, "agent display name", MAX_LABEL_LENGTH);
-    assertId(agent.adapterId, "adapter id");
-    assertIsoDate(agent.createdAt, "agent creation time");
-    if (agent.recoveryReferenceId !== null)
-        assertId(agent.recoveryReferenceId, "recovery reference id");
-    assertAgentCapability(agent.capability);
-    if (agent.runtime !== agent.capability.kind)
-        throw new TypeError("agent runtime must match its capability kind");
-}
-export function assertAgentCapability(capability) {
-    if (capability.kind === "structured") {
-        assertStructuredCapability(capability);
-        return;
-    }
-    assertComposedTerminalCapability(capability);
-}
-export function assertStructuredCapability(capability) {
-    if (capability.protocolVersion !== WORKSPACE_CONTRACT_VERSION)
-        throw new TypeError("unsupported structured protocol version");
-    assertId(capability.adapterId, "structured adapter id");
-    assertUniqueText(capability.commands, "structured commands");
-    assertUniqueText(capability.eventTypes, "structured event types");
-    assertUniqueText(capability.attachmentTypes, "structured attachment types");
-    if (capability.resume === "position" && capability.snapshots === "none") {
-        throw new TypeError("position resume requires authoritative snapshots for gap recovery");
-    }
-    if (capability.resume === "snapshot" && capability.snapshots !== "authoritative") {
-        throw new TypeError("snapshot resume requires authoritative snapshots");
-    }
-    for (const [name, value] of Object.entries(capability.flow))
-        assertBoundedPositiveInteger(value, `structured flow ${name}`);
-}
-export function assertComposedTerminalCapability(capability) {
-    if (capability.protocolVersion !== NATIVE_HOST_PROTOCOL_VERSION)
-        throw new TypeError("unsupported native-host protocol version");
-    assertId(capability.hostInstanceId, "native host instance id");
-    assertRevision(capability.topologyRevision, "topology revision");
-}
-export function assertWorkspaceSnapshot(snapshot) {
-    if (snapshot.contractVersion !== WORKSPACE_CONTRACT_VERSION)
-        throw new TypeError("unsupported workspace contract version");
-    assertId(snapshot.workspaceId, "workspace id");
-    assertRevision(snapshot.revision, "workspace revision");
-    assertCollection(snapshot.agents, "workspace agents");
-    const ids = new Set();
-    for (const agent of snapshot.agents) {
-        assertManagedAgentDescriptor(agent);
-        if (ids.has(agent.id))
-            throw new TypeError(`duplicate agent id: ${agent.id}`);
-        ids.add(agent.id);
-    }
-    if (snapshot.selectedAgentId !== null && !ids.has(snapshot.selectedAgentId)) {
-        throw new TypeError("selected agent must exist in the workspace snapshot");
-    }
-}
-export function assertWorkspaceCommand(command) {
-    assertId(command.correlationId, "command correlation id");
-    switch (command.type) {
-        case "create-agent":
-            assertManagedAgentDescriptor(command.agent);
-            return;
-        case "select-agent":
-        case "stop-agent":
-        case "restart-agent":
-        case "remove-agent":
-            assertId(command.agentId, "command agent id");
-            return;
-        case "rename-agent":
-            assertId(command.agentId, "command agent id");
-            assertText(command.displayName, "agent display name", MAX_LABEL_LENGTH);
-            return;
-        case "structured-command":
-            assertId(command.agentId, "command agent id");
-            assertId(command.command, "structured command name");
-            assertJsonValue(command.payload, "structured command payload");
-            return;
-        case "cancel-structured-command":
-            assertId(command.agentId, "command agent id");
-            assertId(command.targetCorrelationId, "target command correlation id");
-    }
-}
-export function assertWorkspaceEvent(event) {
-    assertId(event.agentId, "event agent id");
-    switch (event.type) {
-        case "agent-lifecycle":
-            assertPosition(event.position, "lifecycle event position");
-            return;
-        case "structured-event":
-            assertPosition(event.position, "structured event position");
-            assertId(event.eventType, "structured event type");
-            assertJsonValue(event.payload, "structured event payload");
-            return;
-        case "command-outcome":
-            assertId(event.correlationId, "command correlation id");
-            return;
-        case "terminal-topology":
-            assertTerminalTopologySnapshot(event.topology);
-            return;
-        case "recovery-discontinuity":
-            assertText(event.reason, "recovery discontinuity reason", 4_096);
-    }
-}
-export function assertStructuredAgentSnapshot(snapshot) {
-    if (snapshot.contractVersion !== WORKSPACE_CONTRACT_VERSION)
-        throw new TypeError("unsupported structured snapshot contract version");
-    assertId(snapshot.agentId, "structured snapshot agent id");
-    assertId(snapshot.snapshotId, "structured snapshot id");
-    assertPosition(snapshot.position, "structured snapshot position");
-    if (snapshot.authoritative !== true)
-        throw new TypeError("structured snapshot must be authoritative");
-    assertJsonValue(snapshot.payload, "structured snapshot payload");
-}
-export function assertTerminalTopologySnapshot(topology) {
-    assertId(topology.hostInstanceId, "native host instance id");
-    assertRevision(topology.revision, "topology revision");
-    assertCollection(topology.windows, "terminal windows");
-    assertCollection(topology.sessions, "terminal sessions");
-    const sessionIds = new Set();
-    for (const session of topology.sessions) {
-        assertTerminalSessionLaunch(session);
-        if (sessionIds.has(session.id))
-            throw new TypeError(`duplicate terminal session id: ${session.id}`);
-        sessionIds.add(session.id);
-    }
-    const windowIds = new Set();
-    const paneIds = new Set();
-    for (const window of topology.windows) {
-        assertId(window.id, "terminal window id");
-        if (windowIds.has(window.id))
-            throw new TypeError(`duplicate terminal window id: ${window.id}`);
-        windowIds.add(window.id);
-        assertCollection(window.tabs, "terminal tabs");
-        if (!window.tabs.some(tab => tab.id === window.activeTabId))
-            throw new TypeError("active tab must exist in its window");
-        const tabIds = new Set();
-        for (const tab of window.tabs) {
-            if (tabIds.has(tab.id))
-                throw new TypeError(`duplicate terminal tab id in window: ${tab.id}`);
-            tabIds.add(tab.id);
-            assertTerminalTab(tab, sessionIds, paneIds);
-        }
-    }
-}
-export function assertNativeHostCommand(command) {
-    assertId(command.correlationId, "native-host correlation id");
-    if (command.type === "apply-topology") {
-        assertRevision(command.expectedRevision, "expected topology revision");
-        assertTerminalTopologySnapshot(command.topology);
-        if (command.topology.revision !== command.expectedRevision) {
-            throw new TypeError("applied topology snapshot revision must equal the expected revision");
-        }
-        return;
-    }
-    if (command.type === "focus-pane" || command.type === "close-pane") {
-        assertRevision(command.expectedRevision, "expected topology revision");
-        assertId(command.paneId, "terminal pane id");
-    }
-}
-export function assertRecoveryAuthority(authority) {
-    assertId(authority.referenceId, "recovery reference id");
-    assertId(authority.agentId, "recovery agent id");
-    assertText(authority.processIdentity, "recovery process identity", 1_024);
-    if (authority.kind === "structured") {
-        assertId(authority.adapterId, "recovery adapter id");
-        assertText(authority.ownershipProof, "recovery ownership proof", 4_096);
-        if (authority.boundary.kind === "position") {
-            assertPosition(authority.boundary.position, "resume position");
-            assertText(authority.boundary.resumeToken, "resume token", 4_096);
-        }
-        else {
-            assertId(authority.boundary.snapshotId, "recovery snapshot id");
-        }
-        return;
-    }
-    assertId(authority.hostInstanceId, "recovery host instance id");
-    assertText(authority.hostBuildId, "recovery host build id", 1_024);
-    assertText(authority.pseudoterminalIdentity, "recovery pseudoterminal identity", 1_024);
-    assertText(authority.retainedStateIdentity, "recovery retained-state identity", 1_024);
-    assertRevision(authority.topologyRevision, "recovery topology revision");
-    assertPosition(authority.streamPosition, "recovery stream position");
-}
-export function assertTerminalSessionLaunch(session) {
-    assertId(session.id, "terminal session id");
-    assertText(session.executable, "terminal executable", 32_768);
-    assertText(session.cwd, "terminal working directory", 32_768);
-    if (session.executable.includes("\0") || session.cwd.includes("\0"))
-        throw new TypeError("terminal launch paths contain a null byte");
-    assertCollection(session.arguments, "terminal arguments", MAX_ARGUMENTS);
-    if (session.arguments.some(argument => typeof argument !== "string" || argument.includes("\0"))) {
-        throw new TypeError("terminal arguments contain an invalid value");
-    }
-    const entries = Object.entries(session.environment);
-    assertCollection(entries, "terminal environment", MAX_ENVIRONMENT_ENTRIES);
-    if (entries.some(([name, value]) => !name || name.includes("=") || name.includes("\0") || typeof value !== "string" || value.includes("\0"))) {
-        throw new TypeError("terminal environment contains an invalid name or value");
-    }
-    assertTerminalDimensions(session.dimensions);
-}
-function assertTerminalDimensions(dimensions) {
-    assertIntegerInRange(dimensions.columns, 2, 500, "terminal columns");
-    assertIntegerInRange(dimensions.rows, 1, 300, "terminal rows");
-    assertIntegerInRange(dimensions.widthPixels, 1, 100_000, "terminal pixel width");
-    assertIntegerInRange(dimensions.heightPixels, 1, 100_000, "terminal pixel height");
-}
-function assertTerminalTab(tab, sessionIds, globalPaneIds) {
-    assertId(tab.id, "terminal tab id");
-    assertCollection(tab.nodes, "terminal topology nodes");
-    assertCollection(tab.panes, "terminal panes");
-    const paneIds = new Set();
-    for (const pane of tab.panes) {
-        assertId(pane.id, "terminal pane id");
-        assertId(pane.sessionId, "terminal pane session id");
-        if (paneIds.has(pane.id) || globalPaneIds.has(pane.id))
-            throw new TypeError(`duplicate terminal pane id: ${pane.id}`);
-        if (!sessionIds.has(pane.sessionId))
-            throw new TypeError(`terminal pane references missing session: ${pane.sessionId}`);
-        paneIds.add(pane.id);
-        globalPaneIds.add(pane.id);
-    }
-    if (!paneIds.has(tab.focusedPaneId))
-        throw new TypeError("focused pane must exist in its tab");
-    const nodes = new Map();
-    for (const node of tab.nodes) {
-        assertId(node.id, "terminal topology node id");
-        if (nodes.has(node.id))
-            throw new TypeError(`duplicate terminal topology node id: ${node.id}`);
-        if (node.kind === "leaf") {
-            if (!paneIds.has(node.paneId))
-                throw new TypeError(`terminal leaf references missing pane: ${node.paneId}`);
-        }
-        else {
-            if (!(node.ratio > 0 && node.ratio < 1 && Number.isFinite(node.ratio)))
-                throw new RangeError("terminal split ratio must be between zero and one");
-            if (node.first === node.second || node.id === node.first || node.id === node.second)
-                throw new TypeError("terminal split cannot reference itself or duplicate a child");
-        }
-        nodes.set(node.id, node);
-    }
-    if (!nodes.has(tab.rootNodeId))
-        throw new TypeError("terminal tab root node is missing");
-    const visited = new Set();
-    const visiting = new Set();
-    const reachedPanes = new Set();
-    visitNode(tab.rootNodeId, nodes, visited, visiting, reachedPanes);
-    if (visited.size !== nodes.size)
-        throw new TypeError("terminal tab contains unreachable topology nodes");
-    if (reachedPanes.size !== paneIds.size || [...paneIds].some(paneId => !reachedPanes.has(paneId))) {
-        throw new TypeError("each terminal pane must appear exactly once in the split tree");
-    }
-}
-function visitNode(id, nodes, visited, visiting, reachedPanes) {
-    const node = nodes.get(id);
-    if (!node)
-        throw new TypeError(`terminal split references missing node: ${id}`);
-    if (visiting.has(id))
-        throw new TypeError("terminal topology contains a cycle");
-    if (visited.has(id))
-        throw new TypeError("terminal topology node has multiple parents");
-    visiting.add(id);
-    if (node.kind === "leaf") {
-        if (reachedPanes.has(node.paneId))
-            throw new TypeError("terminal pane appears more than once in the split tree");
-        reachedPanes.add(node.paneId);
-    }
-    else {
-        visitNode(node.first, nodes, visited, visiting, reachedPanes);
-        visitNode(node.second, nodes, visited, visiting, reachedPanes);
-    }
-    visiting.delete(id);
-    visited.add(id);
-}
-function assertUniqueText(values, name) {
-    assertCollection(values, name);
-    const seen = new Set();
-    for (const value of values) {
-        assertId(value, name);
-        if (seen.has(value))
-            throw new TypeError(`${name} contains a duplicate: ${value}`);
-        seen.add(value);
-    }
-}
-function assertJsonValue(value, name) {
-    try {
-        const encoded = JSON.stringify(value);
-        if (encoded === undefined)
-            throw new TypeError();
-    }
-    catch {
-        throw new TypeError(`${name} must be JSON serializable`);
-    }
-}
-function assertCollection(value, name, maximum = MAX_COLLECTION_LENGTH) {
-    if (!Array.isArray(value) || value.length > maximum)
-        throw new RangeError(`${name} exceeds its maximum length`);
-}
-function assertId(value, name) {
-    assertText(value, name, MAX_ID_LENGTH);
-    if (!/^[A-Za-z0-9][A-Za-z0-9._:-]*$/.test(value))
-        throw new TypeError(`${name} contains unsupported characters`);
-}
-function assertText(value, name, maximum) {
-    if (typeof value !== "string" || value.length === 0 || value.length > maximum || value.includes("\0")) {
-        throw new TypeError(`${name} is invalid`);
-    }
-}
-function assertIsoDate(value, name) {
-    assertText(value, name, 64);
-    if (!Number.isFinite(Date.parse(value)))
-        throw new TypeError(`${name} is not an ISO timestamp`);
-}
-function assertRevision(value, name) {
-    if (!Number.isSafeInteger(value) || value < 0)
-        throw new RangeError(`${name} must be a non-negative safe integer`);
-}
-function assertPosition(value, name) {
-    assertIntegerInRange(value, 0, MAX_POSITION, name);
-}
-function assertBoundedPositiveInteger(value, name) {
-    assertIntegerInRange(value, 1, MAX_LIMIT, name);
-}
-function assertIntegerInRange(value, minimum, maximum, name) {
-    if (!Number.isSafeInteger(value) || value < minimum || value > maximum) {
-        throw new RangeError(`${name} must be an integer from ${minimum} to ${maximum}`);
-    }
-}

package/dist/src/product-identity.d.ts

@@ -1,37 +0,0 @@
-declare const ENVIRONMENT_KEYS: readonly ["certificationTarball", "configDir", "dataDir", "databasePath", "developmentInstanceId", "developmentRoot", "endpoint", "fixture", "fixtureInput", "fixtureToken", "inputAcknowledgement", "internalPackaging", "launchArgumentsJson", "launchProfile", "nativePi", "paneId", "piParityIntentionalMutation", "piPortRoot", "piSourceLedgerPath", "piSourceScanRoot", "probeTrace", "processGuardianPath", "profileHome", "protocolVersion", "releaseDigest", "releaseId", "releaseRoot", "releaseRunnerLabel", "runtimeDir", "structuredFlowLimits", "terminalArgumentsJson", "terminalExecutable", "terminalSessionId"];
-declare const FILESYSTEM_KEYS: readonly ["slug", "windowsDirectory", "unixDirectory", "temporaryPrefix"];
-declare const STATE_KEYS: readonly ["windowsControlDirectory", "unixControlDirectory", "developmentDirectory", "piAgentProfile", "piVanillaProfile", "piSandboxProfile"];
-declare const ENDPOINT_KEYS: readonly ["windowsPipeStem", "unixSocketFilename", "metadataFilename", "supervisorLogFilename", "databaseFilename"];
-declare const MANIFEST_KEYS: readonly ["releaseFilename", "packageFilename"];
-declare const PROTOCOL_KEYS: readonly ["namespace", "controlEnvelope", "supervisorSchema", "nativeHostSchema", "structuredAgentSchema", "controlStoreSchema", "releaseCohortSchema", "updateJournalSchema"];
-declare const EVIDENCE_KEYS: readonly ["nativeSpikeSchema", "terminalProvenanceSchema", "terminalProofSchema", "stableReleaseSchema", "previewReleaseSchema", "releaseCertificationSchema", "previewPlatformVerdictSchema", "piSourceLedgerSchema", "piComponentParitySchema", "piEventFrameParitySchema"];
-declare const ARTIFACT_KEYS: readonly ["cliEntry", "supervisorEntry", "guardianEntry", "uiEntry", "nativeExecutable", "nativeCrate", "processGuardianExecutable", "releaseTarballStem", "diagnosticStem"];
-type StringRecord<Keys extends readonly string[]> = {
-    readonly [Key in Keys[number]]: string;
-};
-export interface ProductIdentity {
-    readonly schema: string;
-    readonly displayName: string;
-    readonly commandName: string;
-    readonly packageName: string;
-    readonly filesystem: StringRecord<typeof FILESYSTEM_KEYS>;
-    readonly environment: StringRecord<typeof ENVIRONMENT_KEYS>;
-    readonly state: StringRecord<typeof STATE_KEYS>;
-    readonly endpoint: StringRecord<typeof ENDPOINT_KEYS>;
-    readonly manifest: StringRecord<typeof MANIFEST_KEYS>;
-    readonly protocol: StringRecord<typeof PROTOCOL_KEYS>;
-    readonly evidence: StringRecord<typeof EVIDENCE_KEYS>;
-    readonly artifacts: StringRecord<typeof ARTIFACT_KEYS>;
-}
-export declare function validateProductIdentity(value: unknown): ProductIdentity;
-export interface ProductIdentityText {
-    readonly displayName: string;
-    readonly commandName: string;
-    readonly packageName: string;
-    readonly diagnostic: (message: string) => string;
-    readonly usage: (forms: readonly string[]) => string;
-}
-export declare function createProductIdentityText(identity: Pick<ProductIdentity, "displayName" | "commandName" | "packageName">): ProductIdentityText;
-export declare const PRODUCT_IDENTITY: ProductIdentity;
-export declare const PRODUCT_TEXT: ProductIdentityText;
-export {};

package/dist/src/product-identity.js

@@ -1,150 +0,0 @@
-import rawIdentity from "./product-identity.json" with { type: "json" };
-const ENVIRONMENT_KEYS = [
-    "certificationTarball",
-    "configDir",
-    "dataDir",
-    "databasePath",
-    "developmentInstanceId",
-    "developmentRoot",
-    "endpoint",
-    "fixture",
-    "fixtureInput",
-    "fixtureToken",
-    "inputAcknowledgement",
-    "internalPackaging",
-    "launchArgumentsJson",
-    "launchProfile",
-    "nativePi",
-    "paneId",
-    "piParityIntentionalMutation",
-    "piPortRoot",
-    "piSourceLedgerPath",
-    "piSourceScanRoot",
-    "probeTrace",
-    "processGuardianPath",
-    "profileHome",
-    "protocolVersion",
-    "releaseDigest",
-    "releaseId",
-    "releaseRoot",
-    "releaseRunnerLabel",
-    "runtimeDir",
-    "structuredFlowLimits",
-    "terminalArgumentsJson",
-    "terminalExecutable",
-    "terminalSessionId",
-];
-const FILESYSTEM_KEYS = ["slug", "windowsDirectory", "unixDirectory", "temporaryPrefix"];
-const STATE_KEYS = ["windowsControlDirectory", "unixControlDirectory", "developmentDirectory", "piAgentProfile", "piVanillaProfile", "piSandboxProfile"];
-const ENDPOINT_KEYS = ["windowsPipeStem", "unixSocketFilename", "metadataFilename", "supervisorLogFilename", "databaseFilename"];
-const MANIFEST_KEYS = ["releaseFilename", "packageFilename"];
-const PROTOCOL_KEYS = ["namespace", "controlEnvelope", "supervisorSchema", "nativeHostSchema", "structuredAgentSchema", "controlStoreSchema", "releaseCohortSchema", "updateJournalSchema"];
-const EVIDENCE_KEYS = ["nativeSpikeSchema", "terminalProvenanceSchema", "terminalProofSchema", "stableReleaseSchema", "previewReleaseSchema", "releaseCertificationSchema", "previewPlatformVerdictSchema", "piSourceLedgerSchema", "piComponentParitySchema", "piEventFrameParitySchema"];
-const ARTIFACT_KEYS = ["cliEntry", "supervisorEntry", "guardianEntry", "uiEntry", "nativeExecutable", "nativeCrate", "processGuardianExecutable", "releaseTarballStem", "diagnosticStem"];
-const ROOT_KEYS = ["schema", "displayName", "commandName", "packageName", "filesystem", "environment", "state", "endpoint", "manifest", "protocol", "evidence", "artifacts"];
-export function validateProductIdentity(value) {
-    const root = exactObject(value, ROOT_KEYS, "product identity");
-    const schema = stringValue(root.schema, "product identity schema");
-    const displayName = stringValue(root.displayName, "product display name");
-    const commandName = stringValue(root.commandName, "product command name");
-    const packageName = stringValue(root.packageName, "product package name");
-    const filesystem = stringObject(root.filesystem, FILESYSTEM_KEYS, "filesystem identity");
-    const environment = stringObject(root.environment, ENVIRONMENT_KEYS, "environment identity");
-    const state = stringObject(root.state, STATE_KEYS, "state identity");
-    const endpoint = stringObject(root.endpoint, ENDPOINT_KEYS, "endpoint identity");
-    const manifest = stringObject(root.manifest, MANIFEST_KEYS, "manifest identity");
-    const protocol = stringObject(root.protocol, PROTOCOL_KEYS, "protocol identity");
-    const evidence = stringObject(root.evidence, EVIDENCE_KEYS, "evidence identity");
-    const artifacts = stringObject(root.artifacts, ARTIFACT_KEYS, "artifact identity");
-    if (!/^[a-z][a-z0-9-]*$/.test(commandName))
-        throw new TypeError("product command name must be a lowercase command slug");
-    if (!/^@[a-z0-9-]+\/[a-z0-9-]+$/.test(packageName))
-        throw new TypeError("product package name must be a lowercase scoped npm package");
-    if (displayName.trim() !== displayName || displayName.length === 0)
-        throw new TypeError("product display name must be non-empty without surrounding whitespace");
-    if (schema !== `${commandName}-product-identity-v1`)
-        throw new TypeError("product identity schema must derive from the command name");
-    if (filesystem.slug !== commandName || filesystem.unixDirectory !== filesystem.slug || filesystem.windowsDirectory !== displayName) {
-        throw new TypeError("product filesystem identity must derive from display and command names");
-    }
-    if (filesystem.temporaryPrefix !== `${filesystem.slug}-`)
-        throw new TypeError("product temporary prefix must derive from the filesystem slug");
-    if (state.windowsControlDirectory !== filesystem.windowsDirectory || state.unixControlDirectory !== filesystem.unixDirectory) {
-        throw new TypeError("product state directories must match the filesystem identity");
-    }
-    if (endpoint.windowsPipeStem !== filesystem.slug)
-        throw new TypeError("product endpoint stem must match the filesystem slug");
-    if (protocol.namespace !== commandName)
-        throw new TypeError("product protocol namespace must match the command name");
-    if (artifacts.diagnosticStem !== filesystem.slug)
-        throw new TypeError("product diagnostic stem must match the filesystem slug");
-    const environmentPrefix = `${commandName.toUpperCase()}_`;
-    const environmentValues = Object.values(environment);
-    if (new Set(environmentValues).size !== environmentValues.length)
-        throw new TypeError("product environment keys must be unique");
-    for (const key of environmentValues) {
-        if (!key.startsWith(environmentPrefix) || !/^[A-Z][A-Z0-9_]+$/.test(key)) {
-            throw new TypeError(`product environment key must use ${environmentPrefix}: ${key}`);
-        }
-    }
-    for (const [name, identifier] of Object.entries(protocol)) {
-        if (name !== "namespace" && !identifier.startsWith(`${protocol.namespace}-`)) {
-            throw new TypeError(`product protocol identifier must use ${protocol.namespace}: ${identifier}`);
-        }
-    }
-    for (const identifier of Object.values(evidence)) {
-        if (!identifier.startsWith(`${protocol.namespace}-`))
-            throw new TypeError(`product evidence identifier must use ${protocol.namespace}: ${identifier}`);
-    }
-    return deepFreeze({
-        schema,
-        displayName,
-        commandName,
-        packageName,
-        filesystem,
-        environment,
-        state,
-        endpoint,
-        manifest,
-        protocol,
-        evidence,
-        artifacts,
-    });
-}
-export function createProductIdentityText(identity) {
-    return Object.freeze({
-        displayName: identity.displayName,
-        commandName: identity.commandName,
-        packageName: identity.packageName,
-        diagnostic: (message) => `${identity.displayName} ${message}`,
-        usage: (forms) => `Usage: ${forms.map(form => `${identity.commandName}${form ? ` ${form}` : ""}`).join(" | ")}`,
-    });
-}
-export const PRODUCT_IDENTITY = validateProductIdentity(rawIdentity);
-export const PRODUCT_TEXT = createProductIdentityText(PRODUCT_IDENTITY);
-function exactObject(value, keys, name) {
-    if (typeof value !== "object" || value === null || Array.isArray(value))
-        throw new TypeError(`${name} must be an object`);
-    const actualKeys = Object.keys(value).sort();
-    const expectedKeys = [...keys].sort();
-    if (actualKeys.length !== expectedKeys.length || actualKeys.some((key, index) => key !== expectedKeys[index])) {
-        throw new TypeError(`${name} must contain exactly: ${expectedKeys.join(", ")}`);
-    }
-    return value;
-}
-function stringObject(value, keys, name) {
-    const object = exactObject(value, keys, name);
-    return Object.fromEntries(keys.map((key) => [key, stringValue(object[key], `${name}.${key}`)]));
-}
-function stringValue(value, name) {
-    if (typeof value !== "string" || value.length === 0)
-        throw new TypeError(`${name} must be a non-empty string`);
-    return value;
-}
-function deepFreeze(value) {
-    if (typeof value !== "object" || value === null || Object.isFrozen(value))
-        return value;
-    for (const child of Object.values(value))
-        deepFreeze(child);
-    return Object.freeze(value);
-}

package/dist/src/product-identity.json

@@ -1,99 +0,0 @@
-{
-    "schema": "a1-product-identity-v1",
-    "displayName": "A1",
-    "commandName": "a1",
-    "packageName": "@timurproko/a1",
-    "filesystem": {
-        "slug": "a1",
-        "windowsDirectory": "A1",
-        "unixDirectory": "a1",
-        "temporaryPrefix": "a1-"
-    },
-    "environment": {
-        "certificationTarball": "A1_CERTIFICATION_TARBALL",
-        "configDir": "A1_CONFIG_DIR",
-        "dataDir": "A1_DATA_DIR",
-        "databasePath": "A1_DATABASE_PATH",
-        "developmentInstanceId": "A1_DEV_INSTANCE_ID",
-        "developmentRoot": "A1_DEV_ROOT",
-        "endpoint": "A1_ENDPOINT",
-        "fixture": "A1_FIXTURE",
-        "fixtureInput": "A1_FIXTURE_INPUT",
-        "fixtureToken": "A1_FIXTURE_TOKEN",
-        "inputAcknowledgement": "A1_INPUT_ACK",
-        "internalPackaging": "A1_INTERNAL_PACKAGING",
-        "launchArgumentsJson": "A1_LAUNCH_ARGUMENTS_JSON",
-        "launchProfile": "A1_LAUNCH_PROFILE",
-        "nativePi": "A1_NATIVE_PI",
-        "paneId": "A1_PANE_ID",
-        "piParityIntentionalMutation": "A1_PI_PARITY_INTENTIONAL_MUTATION",
-        "piPortRoot": "A1_PI_PORT_ROOT",
-        "piSourceLedgerPath": "A1_PI_SOURCE_LEDGER_PATH",
-        "piSourceScanRoot": "A1_PI_SOURCE_SCAN_ROOT",
-        "probeTrace": "A1_PROBE_TRACE",
-        "processGuardianPath": "A1_PROCESS_GUARDIAN_PATH",
-        "profileHome": "A1_PROFILE_HOME",
-        "protocolVersion": "A1_PROTOCOL_VERSION",
-        "releaseDigest": "A1_RELEASE_DIGEST",
-        "releaseId": "A1_RELEASE_ID",
-        "releaseRoot": "A1_RELEASE_ROOT",
-        "releaseRunnerLabel": "A1_RELEASE_RUNNER_LABEL",
-        "runtimeDir": "A1_RUNTIME_DIR",
-        "structuredFlowLimits": "A1_STRUCTURED_FLOW_LIMITS",
-        "terminalArgumentsJson": "A1_TERMINAL_ARGUMENTS_JSON",
-        "terminalExecutable": "A1_TERMINAL_EXECUTABLE",
-        "terminalSessionId": "A1_TERMINAL_SESSION_ID"
-    },
-    "state": {
-        "windowsControlDirectory": "A1",
-        "unixControlDirectory": "a1",
-        "developmentDirectory": "a1-development",
-        "piAgentProfile": ".a1/agent",
-        "piVanillaProfile": ".pi/agent",
-        "piSandboxProfile": ".a1/sandbox"
-    },
-    "endpoint": {
-        "windowsPipeStem": "a1",
-        "unixSocketFilename": "supervisor.sock",
-        "metadataFilename": "supervisor.json",
-        "supervisorLogFilename": "supervisor.log",
-        "databaseFilename": "control.sqlite3"
-    },
-    "manifest": {
-        "releaseFilename": ".a1-release.json",
-        "packageFilename": "package.json"
-    },
-    "protocol": {
-        "namespace": "a1",
-        "controlEnvelope": "a1-control-envelope",
-        "supervisorSchema": "a1-supervisor-v1",
-        "nativeHostSchema": "a1-native-host-v1",
-        "structuredAgentSchema": "a1-structured-agent-v1",
-        "controlStoreSchema": "a1-control-store-v1",
-        "releaseCohortSchema": "a1-release-cohort-v1",
-        "updateJournalSchema": "a1-update-journal-v1"
-    },
-    "evidence": {
-        "nativeSpikeSchema": "a1-native-host-spike-evidence-v1",
-        "terminalProvenanceSchema": "a1-terminal-host-provenance-v1",
-        "terminalProofSchema": "a1-terminal-host-proof-v1",
-        "stableReleaseSchema": "a1-stable-release-v1",
-        "previewReleaseSchema": "a1-preview-release-v1",
-        "releaseCertificationSchema": "a1-release-certification-v1",
-        "previewPlatformVerdictSchema": "a1-development-preview-platform-verdict-v2",
-        "piSourceLedgerSchema": "a1-pinned-pi-source-port-ledger-v1",
-        "piComponentParitySchema": "a1-pi-static-component-parity-v1",
-        "piEventFrameParitySchema": "a1-pi-event-frame-parity-v1"
-    },
-    "artifacts": {
-        "cliEntry": "bin/cli.js",
-        "supervisorEntry": "bin/supervisor.js",
-        "guardianEntry": "bin/guardian.js",
-        "uiEntry": "bin/ui.js",
-        "nativeExecutable": "terminal-host",
-        "nativeCrate": "terminal-host",
-        "processGuardianExecutable": "process-guardian",
-        "releaseTarballStem": "timurproko-a1",
-        "diagnosticStem": "a1"
-    }
-}