@undefineds.co/linx 0.3.20 → 0.3.22

package/dist/skills/symphony/SKILL.md

@@ -581,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/dist/skills/xpod-cli/SKILL.md

@@ -18,14 +18,6 @@ secrets.
 - Read or write RDF resources when the user asks for Pod-level state.
 - Manage AI/provider credentials through secret-safe flows.
 - Verify that LinX, xpod, or another Solid app wrote the expected resource.
-- In Symphony mode, inspect and mutate control-plane resources through `xpod`
-  when the AI is acting from the terminal/tool surface. This includes Idea,
-  Issue, Task, Delivery, Run, RunStep, Report, Evidence, ApprovalRequest,
-  InputRequest, and InboxNotification resources.
-- In capture workflows, use `xpod obj` for model-backed `CaptureCandidate` and
-  `CaptureEvent` resources after the `capture` skill has decided what should
-  be written. xpod does not decide whether something is worth capturing or how
-  it should be classified.
 
 Do not use this skill for xpod CLI repository maintenance. If the task is to
 change xpod command behavior or release xpod itself, use the xpod project docs
@@ -57,12 +49,9 @@ Summarize human-facing output instead of pasting large raw payloads.
 - Authentication has one Solid-app source: `$SOLID_HOME/auth/credentials.json`
   (default `~/.solid/auth/credentials.json`). Old `~/.xpod/config.json` /
   `~/.xpod/secrets.json` files are app-local stale files, not Solid auth; if
-  only those exist, report unauthenticated. If `xpod auth status --json` reports
-  a different WebID or Pod root than the shared Solid auth file, treat that as an
-  auth-store mismatch and stop before writing.
+  only those exist, report unauthenticated.
 - For product resources, do not guess paths. Use model-backed `xpod obj`
-  commands or inspect existing links first. Do not hand-patch modeled product
-  TTL just because a path appears obvious.
+  commands or inspect existing links first.
 
 ## Useful Patterns
 

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@undefineds.co/linx",
-  "version": "0.3.20",
+  "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.44",
+    "@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,9 +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 './coordination.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';
@@ -13,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,9 +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 './coordination.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';
@@ -13,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 {};