@undefineds.co/linx 0.3.19 → 0.3.22

package/dist/skills/symphony/SKILL.md

@@ -82,9 +82,11 @@ LinX control plane, or for local mirrors materialized from Pod.
 
 The portable Symphony runtime contract is storage-agnostic. It may produce
 control records, work splits, prompts, and reports, but it does not own Pod IO.
-LinX product runtime persists through shared models/repositories. A portable AI
-agent may call `xpod` CLI when that tool is available, but `xpod` is an adapter
-tool surface, not something the core Symphony skill or runtime module requires.
+LinX product runtime persists through shared models/repositories. When the
+writer is an AI operating through terminal/tools rather than in-process LinX
+code, `xpod` CLI is the preferred direct Pod tool surface. Use model-backed
+`xpod obj` operations for Symphony resources when available; do not invent a
+parallel Symphony-specific AI tool API and do not hand-patch modeled TTL paths.
 
 In LinX Agent Runtime, Pod authority belongs to the runtime session and should
 be inherited by tools launched inside that session. If a Secretary or worker has
@@ -92,7 +94,9 @@ Pod access, `xpod` commands it runs should use the runtime-provided authority
 bridge. Outside that bridge, all Solid apps share the same local auth source
 `$SOLID_HOME/auth/credentials.json`; old `~/.xpod/config.json` and
 `~/.xpod/secrets.json` files are not Solid auth sources, and their presence
-alone must be treated as unauthenticated. Never ask the model to handle raw
+alone must be treated as unauthenticated. If `xpod auth status --json` reports a
+different WebID or Pod root than the shared Solid auth file, treat it as an
+auth-store mismatch and stop before writing. Never ask the model to handle raw
 tokens, refresh tokens, client secrets, cookies, or DPoP material directly.
 
 ## Agent Config And Skill Resources
@@ -577,6 +581,13 @@ Worker-facing minimum contract:
   should move to models/drizzle-solid/xpod, live-verification gaps, or
   deferred cleanup. Workers may recommend follow-up, but they do not decide
   whether it becomes a new Issue.
+- If the LinX Symphony Codex plugin is installed, prefer its `linx-symphony`
+  MCP tools to check and write the delivery. The MCP helper only validates/writes
+  the portable Delivery file; it does not directly mutate Pod Issues, Tasks,
+  Deliveries, or acceptance state.
+- Otherwise include the same terminal facts in the final report using the
+  `symphonyFinal: true` JSON envelope so LinX can archive the transcript through
+  shared control-plane use-cases; it is not a separate worker schema.
 - Never use chat, Delivery, or repo docs to redefine scope, acceptance,
   compatibility, lifecycle state, or release boundary. Write an Implementation
   Change Request instead.

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@undefineds.co/linx",
-  "version": "0.3.19",
+  "version": "0.3.22",
   "private": false,
   "type": "module",
   "bin": {
     "linx": "dist/index.js"
   },
   "scripts": {
-    "build": "tsc -p tsconfig.json --noEmit && node ./scripts/build.mjs",
+    "build": "node ./scripts/build.mjs",
     "dev": "node ./scripts/dev.mjs",
     "test": "yarn build && NODE_OPTIONS=\"${NODE_OPTIONS:+$NODE_OPTIONS }--preserve-symlinks\" node --test --test-concurrency=1 test/**/*.test.mjs",
     "test:live-acp": "node ./scripts/smoke-auto-mode-acp.mjs"
@@ -18,8 +18,8 @@
     "@earendil-works/pi-ai": "0.78.0",
     "@earendil-works/pi-coding-agent": "0.78.0",
     "@earendil-works/pi-tui": "0.78.0",
-    "@undefineds.co/drizzle-solid": "^0.3.14",
-    "@undefineds.co/models": "0.2.41",
+    "@undefineds.co/drizzle-solid": "0.3.16",
+    "@undefineds.co/models": "0.2.42",
     "@zed-industries/codex-acp": "0.14.0",
     "n3": "^1.26.0",
     "pi-web-access": "^0.10.7",

package/vendor/agent-runtime/dist/chat-reconciler.d.ts

@@ -0,0 +1,33 @@
+import { type ReconcileDecisionSummary, type ReconcilerActorRef, type ReconcilerClientContext, type ThreadControlEvent, type ThreadPolicy, type ThreadPolicyKind } from './reconciler.js';
+export type ChatAppendRole = 'user' | 'assistant' | 'system';
+export type ChatAppendSource = 'web-chat' | 'cli-chat-store' | 'cli-pi-mirror' | 'cli-auto-mode' | 'service-runtime' | 'matrix' | 'secretary-runtime-intent' | 'primary-agent' | 'runtime' | 'worker' | (string & {});
+export interface ChatAppendReconcilerInput {
+    chat?: string;
+    thread: string;
+    resource?: string;
+    role: ChatAppendRole;
+    content: string;
+    actor?: ReconcilerActorRef;
+    source?: ChatAppendSource;
+    policy?: ThreadPolicyKind | ThreadPolicy;
+    autoEnabled?: boolean;
+    secretaryAgent?: string;
+    defaultAssistantAgent?: string;
+    createdAt?: Date | string | number;
+    randomId?: string;
+    client?: ReconcilerClientContext;
+    data?: Record<string, unknown>;
+}
+export interface ChatAppendReconcilerResult {
+    event: ThreadControlEvent;
+    summary: ReconcileDecisionSummary;
+}
+export interface ChatReconcilerMetadata {
+    version: 1;
+    latest: ReconcileDecisionSummary;
+    decisions: ReconcileDecisionSummary[];
+}
+export declare function reconcileChatAppend(input: ChatAppendReconcilerInput): ChatAppendReconcilerResult;
+export declare function createChatAppendEvent(input: ChatAppendReconcilerInput): ThreadControlEvent;
+export declare function appendChatReconcilerMetadata(metadata: Record<string, unknown> | null | undefined, summary: ReconcileDecisionSummary): Record<string, unknown>;
+export declare function readChatReconcilerMetadata(value: unknown): ChatReconcilerMetadata | null;

package/vendor/agent-runtime/dist/chat-reconciler.js

@@ -0,0 +1,108 @@
+import { decideThreadControlEvent } from './thread-reconciler-controller.js';
+export function reconcileChatAppend(input) {
+    const event = createChatAppendEvent(input);
+    const { summary } = decideThreadControlEvent({
+        policy: resolveChatAppendPolicy(input),
+        event,
+        ...(input.chat ? { chat: input.chat } : {}),
+        thread: input.thread,
+        ...(input.createdAt !== undefined ? { now: toDate(input.createdAt) } : {}),
+        randomId: input.randomId ?? input.resource,
+        ...(input.client ? { client: input.client } : {}),
+    });
+    return { event, summary };
+}
+export function createChatAppendEvent(input) {
+    const actor = input.actor ?? defaultActorForChatAppend(input);
+    return {
+        type: 'message.appended',
+        ...(input.chat ? { chat: input.chat } : {}),
+        thread: input.thread,
+        ...(input.resource ? { resource: input.resource } : {}),
+        actor,
+        content: input.content,
+        ...(input.createdAt !== undefined ? { createdAt: toDate(input.createdAt).toISOString() } : {}),
+        data: {
+            ...(input.data ?? {}),
+            role: input.role,
+            ...(input.source ? { source: input.source } : {}),
+        },
+    };
+}
+export function appendChatReconcilerMetadata(metadata, summary) {
+    const base = isRecord(metadata) ? { ...metadata } : {};
+    const existing = readChatReconcilerMetadata(base.reconciler);
+    base.reconciler = {
+        version: 1,
+        latest: summary,
+        decisions: [...(existing?.decisions ?? []), summary],
+    };
+    return base;
+}
+export function readChatReconcilerMetadata(value) {
+    if (!isRecord(value)) {
+        return null;
+    }
+    const latest = isRecord(value.latest) ? value.latest : undefined;
+    const decisions = Array.isArray(value.decisions)
+        ? value.decisions.filter(isRecord).map((item) => item)
+        : [];
+    if (!latest && decisions.length === 0) {
+        return null;
+    }
+    return {
+        version: 1,
+        latest: latest ?? decisions[decisions.length - 1],
+        decisions: decisions.length > 0 ? decisions : [latest],
+    };
+}
+function resolveChatAppendPolicy(input) {
+    if (input.policy) {
+        return input.policy;
+    }
+    if (input.autoEnabled) {
+        return {
+            kind: 'auto',
+            secretaryAgent: input.secretaryAgent ?? '__secretary__',
+            defaultAssistantAgent: input.defaultAssistantAgent,
+        };
+    }
+    return {
+        kind: 'direct',
+        defaultAssistantAgent: input.defaultAssistantAgent ?? 'primary-agent',
+    };
+}
+function defaultActorForChatAppend(input) {
+    if (input.role === 'user') {
+        return { role: 'user' };
+    }
+    if (input.source === 'secretary-runtime-intent') {
+        return { id: input.secretaryAgent ?? '__secretary__', role: 'secretary' };
+    }
+    if (input.source === 'worker') {
+        return { role: 'worker' };
+    }
+    if (input.source === 'runtime') {
+        return { role: 'runtime' };
+    }
+    if (input.source === 'primary-agent') {
+        return { id: input.defaultAssistantAgent ?? 'primary-agent', role: 'primary-agent' };
+    }
+    if (input.role === 'assistant') {
+        return { role: 'assistant' };
+    }
+    return { role: 'runtime' };
+}
+function toDate(value) {
+    if (value instanceof Date) {
+        return value;
+    }
+    const date = new Date(value);
+    if (Number.isNaN(date.getTime())) {
+        throw new Error(`Invalid chat append timestamp: ${String(value)}`);
+    }
+    return date;
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}

package/vendor/agent-runtime/dist/index.d.ts

@@ -3,8 +3,11 @@ export * from './agent-runtime.js';
 export * from './auto-mode.js';
 export * from './companion-model.js';
 export * from './client-inbox-subscription.js';
+export * from './chat-reconciler.js';
 export * from './control-plane.js';
 export * from './file-sync.js';
+export * from './matrix-client.js';
+export * from './pod-resource-identity.js';
 export * from './reconciler.js';
 export * from './runtime.js';
 export * from './symphony.js';
@@ -12,3 +15,4 @@ export * from './sync.js';
 export * from './thread-reconciler-controller.js';
 export * from './turn-controller.js';
 export * from './wake-scheduler.js';
+export * from './workspace.js';

package/vendor/agent-runtime/dist/index.js

@@ -3,8 +3,11 @@ export * from './agent-runtime.js';
 export * from './auto-mode.js';
 export * from './companion-model.js';
 export * from './client-inbox-subscription.js';
+export * from './chat-reconciler.js';
 export * from './control-plane.js';
 export * from './file-sync.js';
+export * from './matrix-client.js';
+export * from './pod-resource-identity.js';
 export * from './reconciler.js';
 export * from './runtime.js';
 export * from './symphony.js';
@@ -12,3 +15,4 @@ export * from './sync.js';
 export * from './thread-reconciler-controller.js';
 export * from './turn-controller.js';
 export * from './wake-scheduler.js';
+export * from './workspace.js';

package/vendor/agent-runtime/dist/matrix-client.d.ts

@@ -0,0 +1,149 @@
+export interface MatrixVersionsResponse {
+    versions: string[];
+    unstable_features?: Record<string, boolean>;
+}
+export interface MatrixLoginFlowsResponse {
+    flows: Array<{
+        type: string;
+    }>;
+}
+export interface MatrixCreateRoomRequest {
+    visibility?: 'private' | 'public';
+    room_alias_name?: string;
+    name?: string;
+    topic?: string;
+    invite?: string[];
+    creation_content?: Record<string, unknown>;
+    initial_state?: Array<{
+        type: string;
+        state_key?: string;
+        content?: Record<string, unknown>;
+    }>;
+    preset?: string;
+    is_direct?: boolean;
+}
+export interface MatrixCreateRoomResponse {
+    room_id: string;
+}
+export interface MatrixWhoamiResponse {
+    user_id: string;
+    device_id?: string;
+    is_guest?: boolean;
+}
+export interface MatrixJoinedRoomsResponse {
+    joined_rooms: string[];
+}
+export interface MatrixJoinRoomResponse {
+    room_id: string;
+}
+export interface MatrixInviteRequest {
+    user_id: string;
+}
+export interface MatrixSetStateResponse {
+    event_id: string;
+}
+export interface MatrixSendEventRequest {
+    body?: string;
+    msgtype?: string;
+    [key: string]: unknown;
+}
+export interface MatrixSendEventResponse {
+    event_id: string;
+}
+export interface MatrixClientEvent {
+    event_id: string;
+    room_id: string;
+    type: string;
+    sender: string;
+    origin_server_ts: number;
+    content: Record<string, unknown>;
+    state_key?: string;
+    unsigned?: Record<string, unknown>;
+}
+export interface MatrixSyncResponse {
+    next_batch: string;
+    rooms: {
+        join: Record<string, {
+            state: {
+                events: MatrixClientEvent[];
+            };
+            timeline: {
+                events: MatrixClientEvent[];
+                limited: boolean;
+                prev_batch?: string;
+            };
+        }>;
+    };
+}
+export interface MatrixMessagesResponse {
+    chunk: MatrixClientEvent[];
+    start?: string;
+    end: string;
+}
+export interface MatrixMembersResponse {
+    chunk: MatrixClientEvent[];
+}
+export interface MatrixClientOptions {
+    baseUrl: string;
+    accessToken?: string;
+    tokenType?: 'Bearer' | 'DPoP' | (string & {});
+    fetch?: typeof fetch;
+    randomId?: () => string;
+}
+export interface MatrixSyncOptions {
+    since?: string;
+    limit?: number;
+    timeout?: number;
+}
+export interface MatrixMessagesOptions {
+    from?: string;
+    dir?: 'b' | 'f';
+    limit?: number;
+}
+export declare class MatrixClientError extends Error {
+    readonly status: number;
+    readonly errcode?: string;
+    readonly body?: unknown;
+    constructor(message: string, input: {
+        status: number;
+        errcode?: string;
+        body?: unknown;
+    });
+}
+export declare class MatrixClient {
+    private readonly baseUrl;
+    private readonly accessToken?;
+    private readonly tokenType;
+    private readonly fetchImpl;
+    private readonly randomId;
+    constructor(options: MatrixClientOptions);
+    versions(): Promise<MatrixVersionsResponse>;
+    loginFlows(): Promise<MatrixLoginFlowsResponse>;
+    whoami(): Promise<MatrixWhoamiResponse>;
+    createRoom(input?: MatrixCreateRoomRequest): Promise<MatrixCreateRoomResponse>;
+    joinedRooms(): Promise<MatrixJoinedRoomsResponse>;
+    joinRoom(roomIdOrAlias: string): Promise<MatrixJoinRoomResponse>;
+    joinRoomById(roomId: string): Promise<MatrixJoinRoomResponse>;
+    inviteUser(roomId: string, userId: string): Promise<Record<string, never>>;
+    leaveRoom(roomId: string): Promise<Record<string, never>>;
+    sendMessage(roomId: string, body: string, options?: {
+        msgtype?: string;
+        txnId?: string;
+        content?: Omit<MatrixSendEventRequest, 'body' | 'msgtype'>;
+    }): Promise<MatrixSendEventResponse>;
+    sendEvent(roomId: string, eventType: string, txnId: string, content?: MatrixSendEventRequest | Record<string, unknown>): Promise<MatrixSendEventResponse>;
+    sync(options?: MatrixSyncOptions): Promise<MatrixSyncResponse>;
+    messages(roomId: string, options?: MatrixMessagesOptions): Promise<MatrixMessagesResponse>;
+    getEvent(roomId: string, eventId: string): Promise<MatrixClientEvent>;
+    getState(roomId: string, eventType: string, stateKey?: string): Promise<Record<string, unknown>>;
+    setState(roomId: string, eventType: string, stateKey: string, content?: Record<string, unknown>): Promise<MatrixSetStateResponse>;
+    members(roomId: string): Promise<MatrixMembersResponse>;
+    private request;
+}
+export declare function createMatrixClient(options: MatrixClientOptions): MatrixClient;
+export declare function matrixServerNameFromBaseUrl(baseUrl: string): string;
+export declare function matrixUserIdFromWebId(webId: string, serverName: string): string;
+export declare function matrixLocalpartFromUserId(userId: string): string;
+export declare function matrixRoomSurfaceId(roomId: string): Promise<string>;
+export declare function matrixChatResourceIdFromRoomId(roomId: string): Promise<string>;
+export declare function matrixThreadResourceIdFromRoomId(roomId: string): Promise<string>;

package/vendor/agent-runtime/dist/matrix-client.js

@@ -0,0 +1,220 @@
+export class MatrixClientError extends Error {
+    status;
+    errcode;
+    body;
+    constructor(message, input) {
+        super(message);
+        this.name = 'MatrixClientError';
+        this.status = input.status;
+        this.errcode = input.errcode;
+        this.body = input.body;
+    }
+}
+export class MatrixClient {
+    baseUrl;
+    accessToken;
+    tokenType;
+    fetchImpl;
+    randomId;
+    constructor(options) {
+        const baseUrl = options.baseUrl.trim();
+        if (!baseUrl) {
+            throw new Error('MatrixClient requires baseUrl');
+        }
+        this.baseUrl = baseUrl.replace(/\/+$/, '');
+        this.accessToken = options.accessToken;
+        this.tokenType = options.tokenType ?? 'Bearer';
+        this.fetchImpl = options.fetch ?? globalThis.fetch;
+        if (typeof this.fetchImpl !== 'function') {
+            throw new Error('MatrixClient requires a fetch implementation');
+        }
+        this.randomId = options.randomId ?? defaultRandomId;
+    }
+    async versions() {
+        return this.request('GET', '/_matrix/client/versions');
+    }
+    async loginFlows() {
+        return this.request('GET', '/_matrix/client/v3/login');
+    }
+    async whoami() {
+        return this.request('GET', '/_matrix/client/v3/account/whoami');
+    }
+    async createRoom(input = {}) {
+        return this.request('POST', '/_matrix/client/v3/createRoom', input);
+    }
+    async joinedRooms() {
+        return this.request('GET', '/_matrix/client/v3/joined_rooms');
+    }
+    async joinRoom(roomIdOrAlias) {
+        return this.request('POST', `/_matrix/client/v3/join/${encodePathSegment(roomIdOrAlias)}`, {});
+    }
+    async joinRoomById(roomId) {
+        return this.request('POST', `/_matrix/client/v3/rooms/${encodePathSegment(roomId)}/join`, {});
+    }
+    async inviteUser(roomId, userId) {
+        return this.request('POST', `/_matrix/client/v3/rooms/${encodePathSegment(roomId)}/invite`, {
+            user_id: userId,
+        });
+    }
+    async leaveRoom(roomId) {
+        return this.request('POST', `/_matrix/client/v3/rooms/${encodePathSegment(roomId)}/leave`, {});
+    }
+    async sendMessage(roomId, body, options = {}) {
+        return this.sendEvent(roomId, 'm.room.message', options.txnId ?? this.randomId(), {
+            ...(options.content ?? {}),
+            msgtype: options.msgtype ?? 'm.text',
+            body,
+        });
+    }
+    async sendEvent(roomId, eventType, txnId, content = {}) {
+        return this.request('PUT', `/_matrix/client/v3/rooms/${encodePathSegment(roomId)}/send/${encodePathSegment(eventType)}/${encodePathSegment(txnId)}`, content);
+    }
+    async sync(options = {}) {
+        return this.request('GET', appendQuery('/_matrix/client/v3/sync', {
+            since: options.since,
+            limit: options.limit,
+            timeout: options.timeout,
+        }));
+    }
+    async messages(roomId, options = {}) {
+        return this.request('GET', appendQuery(`/_matrix/client/v3/rooms/${encodePathSegment(roomId)}/messages`, {
+            from: options.from,
+            dir: options.dir,
+            limit: options.limit,
+        }));
+    }
+    async getEvent(roomId, eventId) {
+        return this.request('GET', `/_matrix/client/v3/rooms/${encodePathSegment(roomId)}/event/${encodePathSegment(eventId)}`);
+    }
+    async getState(roomId, eventType, stateKey = '') {
+        const statePath = stateKey
+            ? `/_matrix/client/v3/rooms/${encodePathSegment(roomId)}/state/${encodePathSegment(eventType)}/${encodePathSegment(stateKey)}`
+            : `/_matrix/client/v3/rooms/${encodePathSegment(roomId)}/state/${encodePathSegment(eventType)}`;
+        return this.request('GET', statePath);
+    }
+    async setState(roomId, eventType, stateKey, content = {}) {
+        const statePath = stateKey
+            ? `/_matrix/client/v3/rooms/${encodePathSegment(roomId)}/state/${encodePathSegment(eventType)}/${encodePathSegment(stateKey)}`
+            : `/_matrix/client/v3/rooms/${encodePathSegment(roomId)}/state/${encodePathSegment(eventType)}`;
+        return this.request('PUT', statePath, content);
+    }
+    async members(roomId) {
+        return this.request('GET', `/_matrix/client/v3/rooms/${encodePathSegment(roomId)}/members`);
+    }
+    async request(method, path, body) {
+        const headers = new Headers();
+        headers.set('Accept', 'application/json');
+        if (body !== undefined) {
+            headers.set('Content-Type', 'application/json');
+        }
+        if (this.accessToken) {
+            headers.set('Authorization', `${this.tokenType} ${this.accessToken}`);
+        }
+        const response = await this.fetchImpl(`${this.baseUrl}${path}`, {
+            method,
+            headers,
+            ...(body !== undefined ? { body: JSON.stringify(body) } : {}),
+        });
+        const parsed = await parseMatrixJson(response);
+        if (!response.ok) {
+            const errorBody = isRecord(parsed) ? parsed : {};
+            const message = typeof errorBody.error === 'string'
+                ? errorBody.error
+                : `Matrix request failed: ${response.status}`;
+            throw new MatrixClientError(message, {
+                status: response.status,
+                errcode: typeof errorBody.errcode === 'string' ? errorBody.errcode : undefined,
+                body: parsed,
+            });
+        }
+        return parsed;
+    }
+}
+export function createMatrixClient(options) {
+    return new MatrixClient(options);
+}
+export function matrixServerNameFromBaseUrl(baseUrl) {
+    return new URL(baseUrl).host;
+}
+export function matrixUserIdFromWebId(webId, serverName) {
+    return `@${matrixLocalpartFromUserId(webId)}:${serverName}`;
+}
+export function matrixLocalpartFromUserId(userId) {
+    try {
+        const url = new URL(userId);
+        const withoutHash = `${url.pathname}${url.hash}`.replace(/^\/+/, '');
+        return matrixSlug(withoutHash || url.host);
+    }
+    catch {
+        return matrixSlug(userId);
+    }
+}
+export async function matrixRoomSurfaceId(roomId) {
+    const digest = await sha256Hex(roomId);
+    return `matrix-${digest.slice(0, 16)}`;
+}
+export async function matrixChatResourceIdFromRoomId(roomId) {
+    return `${await matrixRoomSurfaceId(roomId)}/index.ttl#this`;
+}
+export async function matrixThreadResourceIdFromRoomId(roomId) {
+    return `chat/${await matrixRoomSurfaceId(roomId)}/index.ttl#thread`;
+}
+function appendQuery(path, values) {
+    const params = new URLSearchParams();
+    for (const [key, value] of Object.entries(values)) {
+        if (value === undefined) {
+            continue;
+        }
+        params.set(key, String(value));
+    }
+    const query = params.toString();
+    return query ? `${path}?${query}` : path;
+}
+function encodePathSegment(value) {
+    return encodeURIComponent(value);
+}
+async function parseMatrixJson(response) {
+    const text = await response.text();
+    if (!text.trim()) {
+        return null;
+    }
+    try {
+        return JSON.parse(text);
+    }
+    catch (error) {
+        if (!response.ok) {
+            throw new MatrixClientError(`Matrix request returned non-JSON error: ${response.status}`, {
+                status: response.status,
+                body: text,
+            });
+        }
+        throw error;
+    }
+}
+function defaultRandomId() {
+    return globalThis.crypto?.randomUUID?.() ?? Math.random().toString(36).slice(2, 12);
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function matrixSlug(value) {
+    return value.toLowerCase().replace(/[^a-z0-9._=-]+/g, '_').replace(/^_+|_+$/g, '') || 'user';
+}
+async function sha256Hex(value) {
+    const subtle = await resolveSubtleCrypto();
+    if (!subtle) {
+        throw new Error('Matrix room resource mapping requires Web Crypto SHA-256 support.');
+    }
+    const digest = await subtle.digest('SHA-256', new TextEncoder().encode(value));
+    return Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, '0')).join('');
+}
+async function resolveSubtleCrypto() {
+    if (globalThis.crypto?.subtle) {
+        return globalThis.crypto.subtle;
+    }
+    if (typeof process !== 'undefined' && process.versions?.node) {
+        const nodeCrypto = await import('node:crypto');
+        return nodeCrypto.webcrypto.subtle;
+    }
+    return null;
+}

package/vendor/agent-runtime/dist/pod-resource-identity.d.ts

@@ -0,0 +1,17 @@
+declare const baseRelativeResourceIdBrand: unique symbol;
+declare const resourceIriBrand: unique symbol;
+export type BaseRelativeResourceId = string & {
+    readonly [baseRelativeResourceIdBrand]: 'BaseRelativeResourceId';
+};
+export type ResourceIri = string & {
+    readonly [resourceIriBrand]: 'ResourceIri';
+};
+export declare function asBaseRelativeResourceId(value: string, label?: string): BaseRelativeResourceId;
+export declare function asResourceIri(value: string, label?: string): ResourceIri;
+export declare function requireRowResourceId(row: {
+    id?: string | null;
+} | null | undefined, label?: string): BaseRelativeResourceId;
+export declare function agentResourceId(key?: string | null): BaseRelativeResourceId;
+export declare function agentKeyFromResourceId(resourceId: string): string;
+export declare function agentHomeDirFromResourceId(resourceId: string): BaseRelativeResourceId;
+export {};