@undefineds.co/xpod 0.4.19 → 0.4.25

package/dist/api/handlers/TaskHandler.d.ts

@@ -0,0 +1,41 @@
+import type { ApiServer } from '../ApiServer';
+import type { AuthenticatedRequest } from '../middleware/AuthMiddleware';
+import type { StoreContext } from '../chatkit/store';
+import type { TaskService } from '../tasks/TaskService';
+import type { TaskAuthBindingSnapshot } from '../tasks/TaskAuthBinding';
+import type { TaskRecordData } from '../tasks/store';
+import type { RunStore } from '../runs/store';
+export interface TaskHandlerOptions {
+    taskService: TaskService<StoreContext>;
+    runStore: RunStore<StoreContext>;
+    resolveExecutionContext?: (task: TaskRecordData, caller: StoreContext) => Promise<StoreContext | undefined>;
+    /** Agent identity and its own granted credential; never inferred from the human's key. */
+    resolveAgentBinding?: (request: AuthenticatedRequest) => Promise<{
+        assignedTo: string;
+        authBinding: TaskAuthBindingSnapshot;
+    } | undefined>;
+}
+/** UI reads durable Pod projections; the scheduler is never a query backend. */
+export declare function registerTaskRoutes(server: ApiServer, options: TaskHandlerOptions): void;
+export declare function projectTask(task: TaskRecordData): {
+    id: string;
+    title: string | undefined;
+    instruction: string;
+    assignedTo: string | undefined;
+    source: string | undefined;
+    status: import("@undefineds.co/models").TaskStatusType;
+    dueAt: number | undefined;
+    completedAt: number | undefined;
+    notes: string | undefined;
+    priority: string | undefined;
+    createdAt: number;
+    updatedAt: number;
+    schedule: {
+        kind: import("../tasks").TaskTriggerKindType;
+        cron: string | undefined;
+        intervalSeconds: number | undefined;
+        eventName: string | undefined;
+        nextRunAt: number | undefined;
+        paused: boolean;
+    } | undefined;
+};

package/dist/api/handlers/TaskHandler.js

@@ -0,0 +1,195 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerTaskRoutes = registerTaskRoutes;
+exports.projectTask = projectTask;
+const RunCancellation_1 = require("../runs/RunCancellation");
+const PodAccessFailureResponse_1 = require("./PodAccessFailureResponse");
+/** UI reads durable Pod projections; the scheduler is never a query backend. */
+function registerTaskRoutes(server, options) {
+    const guarded = (handler) => async (request, response) => {
+        if (request.auth?.type !== 'solid') {
+            send(response, 401, { error: 'Authentication required' });
+            return;
+        }
+        try {
+            send(response, 200, await handler(request, { userId: request.auth.webId, auth: request.auth }, request.auth.webId));
+        }
+        catch (error) {
+            if ((0, PodAccessFailureResponse_1.sendPodAccessFailure)(response, error))
+                return;
+            send(response, 400, { error: error instanceof Error ? error.message : 'Task request failed' });
+        }
+    };
+    const idOf = (request) => {
+        const id = new URL(request.url ?? '', 'http://localhost').searchParams.get('id');
+        if (!id)
+            throw new Error('Resource id is required');
+        return id;
+    };
+    server.get('/api/tasks', guarded(async (_request, context, owner) => {
+        const [tasks, waiting] = await Promise.all([
+            options.taskService.listTasks(context), options.runStore.listRuns({ status: 'waiting_input' }, context),
+        ]);
+        const waitingTasks = new Set(waiting.map(run => run.task));
+        return {
+            tasks: tasks.map(task => ({ ...projectTask(task), iri: task.id, waiting: waitingTasks.has(task.id) })),
+            capabilities: { createAi: Boolean(await options.resolveAgentBinding?.(_request).catch(() => undefined)), resumeStep: false, handoff: false, approve: true },
+        };
+    }));
+    server.post('/api/tasks', guarded(async (request, context, owner) => {
+        const input = await body(request);
+        const prompt = requiredString(input.prompt, 'Instruction');
+        const workspace = requiredString(input.workspace, 'Workspace');
+        if (input.kind === 'todo') {
+            return { task: projectTask(await options.taskService.createTodo({
+                    prompt, workspace, assignedTo: owner,
+                    dueAt: optionalTimestamp(input.dueAt),
+                    notes: optionalString(input.notes), priority: optionalString(input.priority), source: optionalUri(input.source),
+                }, context)) };
+        }
+        if (!options.resolveAgentBinding)
+            throw new Error('代理执行身份待接入');
+        if (input.kind !== 'cron' && input.kind !== 'interval' && input.kind !== 'event')
+            throw new Error('Choose cron, interval or event');
+        const binding = await options.resolveAgentBinding(request);
+        if (!binding)
+            throw new Error('代理执行凭据尚未授权');
+        if (binding.assignedTo === owner)
+            throw new Error('AI tasks must be assigned to the agent');
+        if (binding.authBinding.webId !== owner)
+            throw new Error('Task credential belongs to another Pod owner');
+        const result = await options.taskService.createTask({
+            prompt, title: prompt, workspace, ...binding, triggerKind: input.kind, source: optionalUri(input.source),
+            cron: optionalString(input.cron), intervalSeconds: optionalTimestamp(input.intervalSeconds),
+            eventName: optionalString(input.eventName),
+        }, context);
+        return { task: projectTask(result.task) };
+    }));
+    server.patch('/api/tasks', guarded(async (request, context, owner) => {
+        const input = await body(request);
+        if (input.completed !== undefined && typeof input.completed !== 'boolean')
+            throw new Error('completed must be boolean');
+        return { task: projectTask(await options.taskService.updateTodo(idOf(request), owner, {
+                completed: input.completed,
+                dueAt: input.dueAt === null ? null : optionalTimestamp(input.dueAt),
+                notes: optionalString(input.notes), priority: optionalString(input.priority),
+            }, context)) };
+    }));
+    server.post('/api/tasks/pause', guarded(async (request, context) => {
+        const input = await body(request);
+        if (typeof input.paused !== 'boolean')
+            throw new Error('paused must be boolean');
+        return { task: projectTask(await options.taskService.setSchedulePaused(idOf(request), input.paused, context)) };
+    }));
+    server.post('/api/tasks/run', guarded(async (request, context) => {
+        const task = await options.taskService.loadTask(idOf(request), context);
+        const execution = await options.resolveExecutionContext?.(task, context);
+        if (!execution)
+            throw new Error('代理执行凭据待接入或已失效');
+        // Re-read under the execution context: resolving the identity above may have changed the Task
+        // (for example a pause), and the run must materialize from the freshest persisted state.
+        const result = await options.taskService.runNow(task.id, execution);
+        return { task: projectTask(result.task), run: projectRun(result.run) };
+    }));
+    server.get('/api/tasks/runs', guarded(async (request, context, owner) => {
+        const task = await options.taskService.loadTask(idOf(request), context);
+        return { runs: (await options.runStore.listRuns({ task: task.id }, context)).map(projectRun) };
+    }));
+    server.post('/api/tasks/resume', guarded(async (request, context, owner) => {
+        const input = await body(request);
+        const approval = requiredString(input.approval, 'Approval');
+        const target = idOf(request);
+        const run = (await options.runStore.listRuns({}, context)).find(item => item.id === target)
+            ?? (target.startsWith('https://') || target.startsWith('http://') ? undefined : await options.runStore.loadRun(target, context));
+        if (!run)
+            throw new Error('Run not found');
+        const result = await options.taskService.resumeApprovedRun({ runId: run.id, approval, owner }, context, options.resolveExecutionContext);
+        return { ...result, run: projectRun(result.run) };
+    }));
+    server.get('/api/tasks/selection', guarded(async (request, context, owner) => {
+        const target = idOf(request);
+        const runs = await options.runStore.listRuns({}, context);
+        const run = runs.find(item => item.id === target);
+        if (!run)
+            throw new Error('Run not found');
+        const tasks = await options.taskService.listTasks(context);
+        const task = tasks.find(item => item.id === run.task);
+        if (!task)
+            throw new Error('Task not found for this run');
+        return { taskId: task.id, run: projectRun(run) };
+    }));
+    server.get('/api/tasks/steps', guarded(async (request, context) => ({
+        steps: (await options.runStore.loadRunSteps(idOf(request), context)).map(step => ({
+            id: step.id, type: step.type, message: step.message, createdAt: step.createdAt,
+        })),
+    })));
+    server.post('/api/tasks/stop', guarded(async (request, context, owner) => {
+        const run = await (0, RunCancellation_1.cancelRun)({
+            store: options.runStore, runId: idOf(request), context,
+            resourceIri: run => run.id,
+        });
+        return { run: projectRun(run) };
+    }));
+}
+function projectTask(task) {
+    return {
+        id: task.id, title: task.title, instruction: task.prompt, assignedTo: task.assignedTo,
+        source: task.source, status: task.status, dueAt: task.dueAt, completedAt: task.completedAt,
+        notes: task.notes, priority: task.priority, createdAt: task.createdAt, updatedAt: task.updatedAt,
+        schedule: task.authBinding ? {
+            kind: task.triggerKind, cron: task.cron, intervalSeconds: task.intervalSeconds,
+            eventName: task.eventName, nextRunAt: task.nextRunAt, paused: task.status === 'blocked',
+        } : undefined,
+    };
+}
+function projectRun(run) {
+    const waitingTool = run.metadata?.waitingTool;
+    return { id: run.id, thread: run.thread, status: run.status, error: run.error, createdAt: run.createdAt,
+        waitingToolCallId: waitingTool?.requestId,
+        completedAt: run.completedAt, cancelRequestedAt: run.cancelRequestedAt };
+}
+function requiredString(value, label) {
+    if (typeof value !== 'string' || !value.trim())
+        throw new Error(`${label} is required`);
+    return value.trim();
+}
+function optionalString(value) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== 'string')
+        throw new Error('Expected text');
+    return value;
+}
+function optionalUri(value) {
+    const text = optionalString(value);
+    if (text !== undefined && !/^https?:\/\//.test(text))
+        throw new Error('Source must be an HTTP resource IRI');
+    return text;
+}
+function optionalTimestamp(value) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== 'number' || !Number.isFinite(value) || value < 0)
+        throw new Error('Expected a positive number');
+    return value;
+}
+async function body(request) {
+    const chunks = [];
+    let bytes = 0;
+    for await (const chunk of request) {
+        const buffer = Buffer.from(chunk);
+        bytes += buffer.length;
+        if (bytes > 64 * 1024)
+            throw new Error('Request is too large');
+        chunks.push(buffer);
+    }
+    const value = JSON.parse(Buffer.concat(chunks).toString('utf8'));
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        throw new Error('Expected a JSON object');
+    return value;
+}
+function send(response, status, value) {
+    response.writeHead(status, { 'Content-Type': 'application/json' });
+    response.end(JSON.stringify(value));
+}
+//# sourceMappingURL=TaskHandler.js.map

package/dist/api/matrix/PodMatrixStore.js

@@ -195,28 +195,34 @@ class PodMatrixStore {
     }
     async sendEvent(roomId, eventType, txnId, content, context) {
         const db = await this.getDb(context);
-        await this.requireJoined(db, roomId, context);
+        // Reuse the room and timeline within this operation. The exact receipt lookup
+        // remains independent: its resource may have moved out of this timeline.
+        const room = await this.roomSource(db, roomId);
+        const events = await this.listEvents(db, roomId, context);
+        await this.requireJoined(db, roomId, context, events, room);
         if (eventType !== 'm.room.message')
             throw new MatrixError_1.MatrixError(400, 'M_UNRECOGNIZED', 'Only m.room.message timeline events are supported');
-        await this.authorizeTargets(db, roomId, content, context);
+        await this.authorizeTargets(db, roomId, content, context, events);
         const reservation = await this.journal.reserveTransaction(this.scope(context), JSON.stringify([this.deviceId(context), roomId, eventType, txnId]), {
             eventId: this.generateEventId(context), createdAt: Date.now(), contentHash: this.hash(this.canonicalJson(['user', context.webId, eventType, content])),
         });
         if (reservation.contentHash !== this.hash(this.canonicalJson(['user', context.webId, eventType, content]))) {
             throw new MatrixError_1.MatrixError(409, 'M_CONFLICT', 'Transaction already reserved with different content');
         }
-        const source = await db.findById(models_1.messageResource, this.messageResourceIdFromEvent(roomId, reservation.eventId, reservation.createdAt));
+        const resourceId = this.messageResourceIdFromEvent(roomId, reservation.eventId, reservation.createdAt);
+        const source = await db.findById(models_1.messageResource, resourceId);
         if (source) {
             const existing = this.eventSourceToRecord(source, roomId, context);
             if (reservation.contentHash !== this.hash(this.canonicalJson(['user', existing.senderWebId, existing.type, existing.content]))) {
                 throw new MatrixError_1.MatrixError(409, 'M_CONFLICT', 'Stored event no longer matches its receipt');
             }
             existing.depth = await this.journal.registerEvent(this.scope(context), roomId, existing.eventId);
-            await this.reconcileEvent(db, existing, context);
+            await this.reconcileEvent(db, existing, context, events);
             return existing;
         }
         return this.appendEvent(db, { roomId, type: eventType, sender: this.getMatrixUserId(context), txnId,
-            eventId: reservation.eventId, originServerTs: reservation.createdAt, content }, context);
+            eventId: reservation.eventId, originServerTs: reservation.createdAt, content,
+            roomContext: { metadata: this.parseJsonObject(room.metadata), participants: (0, reconciler_1.normalizeAgentUris)(room.participants) } }, context);
     }
     async setState(roomId, eventType, stateKey, content, context) {
         const db = await this.getDb(context);
@@ -383,7 +389,8 @@ class PodMatrixStore {
         const originIso = new Date(input.originServerTs).toISOString();
         const needsRoomMetadata = input.reconcilerOwner === undefined
             || (input.type === 'm.room.message' && this.serverGroupReconcilerService !== undefined);
-        const roomContext = needsRoomMetadata ? await this.getRoomContext(db, input.roomId) : undefined;
+        const roomContext = input.roomContext
+            ?? (needsRoomMetadata ? await this.getRoomContext(db, input.roomId) : undefined);
         const roomMetadata = roomContext?.metadata;
         const reconcilerOwner = input.reconcilerOwner ?? this.reconcilerOwnerFromRoomMetadata(roomMetadata);
         const coordination = (0, reconciler_1.reconcilerCoordinationMetadata)(reconcilerOwner);
@@ -599,10 +606,10 @@ class PodMatrixStore {
         if ((await this.roomSource(db, roomId)).author !== context.webId)
             throw new MatrixError_1.MatrixError(403, 'M_FORBIDDEN', 'Room owner authority is required');
     }
-    async requireJoined(db, roomId, context, events) {
-        const room = await this.roomSource(db, roomId);
+    async requireJoined(db, roomId, context, events, room) {
+        const loaded = room ?? await this.roomSource(db, roomId);
         const state = events ? this.latestState(events, 'm.room.member', this.getMatrixUserId(context)) : await this.findLatestStateEvent(db, roomId, 'm.room.member', this.getMatrixUserId(context), context);
-        if (state?.content.membership === 'join' || (!state && room.author === context.webId))
+        if (state?.content.membership === 'join' || (!state && loaded.author === context.webId))
             return;
         throw new MatrixError_1.MatrixError(403, 'M_FORBIDDEN', 'Join the room before accessing its timeline');
     }

package/dist/api/network/EndpointReachabilityProbe.d.ts

@@ -0,0 +1,40 @@
+import { type HeadProbeRequest, type ResolveAddresses } from '../../edge/ProbeTargetGuard';
+/**
+ * "Is my public entry actually serving?" — asked on demand, never on a timer (audit N12).
+ *
+ * The settings page used to answer only "the address is configured". The operator now gets a
+ * real measurement, but the probe is deliberately narrow, because it makes the node issue an
+ * outbound request to a configured address:
+ *
+ *   - it only ever runs when the operator asks (the diagnose action), never periodically;
+ *   - only `https` targets are accepted: an entry that serves plaintext is a configuration
+ *     error, and probing it would put the operator's traffic on the wire unencrypted;
+ *   - every resolved address must be public (the same guard the Cloud probe uses), so the
+ *     entry cannot bounce the node into loopback, RFC1918, link-local or the metadata
+ *     endpoint, and each redirect hop is validated again;
+ *   - the connection is pinned to the address that was validated, so a second DNS answer
+ *     cannot swap in a private address between check and connect;
+ *   - the verdict says "reachable from this node" and nothing more: many networks do not
+ *     support NAT hairpin, so a node failing to reach its own public entry is not proof that
+ *     remote users cannot, and vice versa.
+ */
+export interface EndpointReachabilityProbeOptions {
+    resolveAddresses?: ResolveAddresses;
+    headRequest?: HeadProbeRequest;
+    timeoutMs?: number;
+    maxRedirects?: number;
+    now?: () => Date;
+}
+export type EndpointReachabilityVerdict = 'reachable-from-this-node' | 'unreachable' | 'blocked';
+export interface EndpointReachabilityResult {
+    target: string;
+    verdict: EndpointReachabilityVerdict;
+    /** Present whenever the entry answered at all (including 4xx: the entry is serving). */
+    httpStatus?: number;
+    /** Time from the first request to the final answer, including redirects. */
+    latencyMs?: number;
+    reason?: string;
+    detail: string;
+    checkedAt: string;
+}
+export declare function probeEndpointReachability(endpoint: string, options?: EndpointReachabilityProbeOptions): Promise<EndpointReachabilityResult>;

package/dist/api/network/EndpointReachabilityProbe.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.probeEndpointReachability = probeEndpointReachability;
+const ProbeTargetGuard_1 = require("../../edge/ProbeTargetGuard");
+const DEFAULT_TIMEOUT_MS = 5_000;
+const DEFAULT_MAX_REDIRECTS = 3;
+async function probeEndpointReachability(endpoint, options = {}) {
+    const now = options.now ?? (() => new Date());
+    const checkedAt = now().toISOString();
+    const timeoutMs = positive(options.timeoutMs, DEFAULT_TIMEOUT_MS);
+    const maxRedirects = Math.max(0, Math.trunc(options.maxRedirects ?? DEFAULT_MAX_REDIRECTS));
+    const resolveAddresses = options.resolveAddresses;
+    const headRequest = options.headRequest ?? (0, ProbeTargetGuard_1.createPinnedHeadProbeRequest)();
+    const startUrl = parseEndpointUrl(endpoint);
+    if (!startUrl) {
+        return {
+            target: endpoint,
+            verdict: 'blocked',
+            reason: 'invalid-url',
+            detail: 'cannot probe: the address is not a usable URL',
+            checkedAt,
+        };
+    }
+    // Plaintext entries are not probed: the point of the check is the entry users reach, and an
+    // operator needs to fix the scheme before anything else is meaningful.
+    if (startUrl.protocol !== 'https:') {
+        return {
+            target: startUrl.toString(),
+            verdict: 'blocked',
+            reason: `insecure-scheme:${startUrl.protocol}`,
+            detail: 'not probed: only https entries are probed',
+            checkedAt,
+        };
+    }
+    const startedAt = Date.now();
+    let url = startUrl;
+    for (let hop = 0; hop <= maxRedirects; hop += 1) {
+        const decision = await (0, ProbeTargetGuard_1.assertPublicProbeTarget)(url, resolveAddresses);
+        if (!decision.allowed) {
+            return {
+                target: startUrl.toString(),
+                verdict: 'blocked',
+                reason: `blocked-target:${decision.reason}`,
+                detail: `not probed: ${decision.reason}（只对公网地址发探测）`,
+                checkedAt,
+            };
+        }
+        let response;
+        try {
+            response = await headRequest(url, { address: decision.address, timeoutMs });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            const timedOut = /timed? ?out|ETIMEDOUT|aborted/iu.test(message);
+            return {
+                target: startUrl.toString(),
+                verdict: 'unreachable',
+                reason: timedOut ? 'timeout' : `connection-error:${message}`,
+                latencyMs: Date.now() - startedAt,
+                detail: timedOut
+                    ? `unreachable from this node: no answer within ${timeoutMs}ms`
+                    : `unreachable from this node: ${message}`,
+                checkedAt,
+            };
+        }
+        if (response.status >= 300 && response.status < 400 && response.location) {
+            const next = safeUrl(response.location, url);
+            if (!next) {
+                return {
+                    target: startUrl.toString(),
+                    verdict: 'unreachable',
+                    reason: 'invalid-redirect',
+                    latencyMs: Date.now() - startedAt,
+                    detail: 'unreachable from this node: the entry redirected to an unusable address',
+                    checkedAt,
+                };
+            }
+            url = next;
+            continue;
+        }
+        const latencyMs = Date.now() - startedAt;
+        return {
+            target: startUrl.toString(),
+            verdict: 'reachable-from-this-node',
+            httpStatus: response.status,
+            latencyMs,
+            detail: `reachable from this node: HTTP ${response.status} in ${latencyMs}ms`
+                + '（网络可能不支持回环，不代表外部用户可达）',
+            checkedAt,
+        };
+    }
+    return {
+        target: startUrl.toString(),
+        verdict: 'unreachable',
+        reason: 'too-many-redirects',
+        latencyMs: Date.now() - startedAt,
+        detail: `unreachable from this node: more than ${maxRedirects} redirects`,
+        checkedAt,
+    };
+}
+function parseEndpointUrl(value) {
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    try {
+        return new URL(trimmed);
+    }
+    catch {
+        try {
+            return new URL(`https://${trimmed}`);
+        }
+        catch {
+            return undefined;
+        }
+    }
+}
+function safeUrl(value, base) {
+    try {
+        return new URL(value, base);
+    }
+    catch {
+        return undefined;
+    }
+}
+function positive(value, fallback) {
+    return typeof value === 'number' && Number.isFinite(value) && value > 0 ? Math.trunc(value) : fallback;
+}
+//# sourceMappingURL=EndpointReachabilityProbe.js.map

package/dist/api/runs/AgentRuntimeTypes.d.ts

@@ -91,6 +91,13 @@ export type AgentRuntimeEvent = {
     }>;
 } | {
     type: 'tool_call';
+    /** A request for human authority; the action has not been executed. */
+    approval?: {
+        target: string;
+        action: string;
+        risk: 'low' | 'medium' | 'high';
+        description: string;
+    };
     requestId: string;
     name: string;
     arguments: string;

package/dist/api/runs/ConditionalResourceDocument.d.ts

@@ -0,0 +1,20 @@
+import type { Quad } from '@rdfjs/types';
+interface ResourceColumn {
+    dataType: string;
+    options: {
+        predicate?: string;
+    };
+}
+/** Temporary exact-write adapter; see docs/issues/2026-10-02-approval-conditional-update.md. */
+export declare function updateConditionalResource<T>(input: {
+    iri: string;
+    fetch: typeof fetch;
+    columns: Record<string, ResourceColumn>;
+    serialize(values: Record<string, unknown>): string;
+    update(quads: Quad[]): {
+        result: T;
+        values?: Record<string, unknown>;
+    };
+}): Promise<T>;
+export declare function resourceLiteral(quads: Quad[], iri: string, predicate: string): string | undefined;
+export {};

package/dist/api/runs/ConditionalResourceDocument.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateConditionalResource = updateConditionalResource;
+exports.resourceLiteral = resourceLiteral;
+const n3_1 = require("n3");
+const sparqljs_1 = require("sparqljs");
+/** Temporary exact-write adapter; see docs/issues/2026-10-02-approval-conditional-update.md. */
+async function updateConditionalResource(input) {
+    const url = new URL(input.iri);
+    if (!['http:', 'https:'].includes(url.protocol) || url.username || url.password)
+        throw new Error('Run resource must be an HTTP(S) IRI');
+    url.hash = '';
+    const documentUrl = url.href;
+    for (let attempt = 0; attempt < 8; attempt += 1) {
+        const response = await input.fetch(documentUrl, {
+            headers: { accept: 'text/turtle' }, cache: 'no-store', redirect: 'error',
+        });
+        if (!response.ok)
+            throw new Error(`Run document read failed: HTTP ${response.status}`);
+        const etag = response.headers.get('etag');
+        const text = await response.text();
+        if (!etag || !/^"[^"\r\n]+"$/.test(etag))
+            throw new Error('Run updates require a strong document ETag');
+        if (!response.headers.get('content-type')?.toLowerCase().includes('text/turtle'))
+            throw new Error('Run updates require a Turtle document');
+        const quads = new n3_1.Parser({ baseIRI: documentUrl }).parse(text);
+        const update = input.update(quads);
+        if (!update.values)
+            return update.result;
+        const inserted = insertQuads(input.serialize(update.values), documentUrl, input.iri);
+        const changedPredicates = new Set(Object.keys(update.values).map(key => input.columns[key]?.options.predicate).filter(Boolean));
+        const inlinePredicates = new Set(Object.keys(update.values)
+            .filter(key => ['object', 'json', 'array'].includes(input.columns[key]?.dataType))
+            .map(key => input.columns[key]?.options.predicate).filter(Boolean));
+        const owned = new Set();
+        const keyOf = (term) => `${term.termType}:${term.value}`;
+        const isOwned = (term) => term.termType === 'BlankNode'
+            || (term.termType === 'NamedNode' && term.value.startsWith(`${input.iri}/`));
+        for (const quad of quads) {
+            if (quad.subject.value === input.iri && inlinePredicates.has(quad.predicate.value) && isOwned(quad.object))
+                owned.add(keyOf(quad.object));
+        }
+        let size = -1;
+        while (size !== owned.size) {
+            size = owned.size;
+            for (const quad of quads)
+                if (owned.has(keyOf(quad.subject)) && isOwned(quad.object))
+                    owned.add(keyOf(quad.object));
+        }
+        const preserved = quads.filter(quad => !owned.has(keyOf(quad.subject))
+            && !(quad.subject.value === input.iri && changedPredicates.has(quad.predicate.value)));
+        const store = new n3_1.Store([...preserved, ...inserted]);
+        const body = await new Promise((resolve, reject) => {
+            const writer = new n3_1.Writer({ format: 'Turtle' });
+            writer.addQuads(store.getQuads(null, null, null, null));
+            writer.end((error, output) => error ? reject(error) : resolve(output));
+        });
+        const result = await input.fetch(documentUrl, {
+            method: 'PUT', headers: { 'content-type': 'text/turtle', 'if-match': etag }, body, redirect: 'error',
+        });
+        await result.arrayBuffer();
+        if (result.status === 412)
+            continue; // Re-read and recompute; never replay stale state.
+        if (!result.ok)
+            throw new Error(`Run document update failed: HTTP ${result.status}`);
+        return update.result;
+    }
+    throw new Error('Run document changed repeatedly during conditional update');
+}
+function resourceLiteral(quads, iri, predicate) {
+    const values = quads.filter(quad => quad.subject.termType === 'NamedNode' && quad.subject.value === iri && quad.predicate.value === predicate);
+    if (values.length > 1 || values.some(quad => quad.object.termType !== 'Literal'))
+        throw new Error('Ambiguous Run lifecycle state');
+    return values[0]?.object.value;
+}
+function insertQuads(query, documentUrl, iri) {
+    const parsed = new sparqljs_1.Parser().parse(query);
+    if (parsed.type !== 'update')
+        throw new Error('Expected ORM INSERT serialization');
+    const output = [];
+    for (const update of parsed.updates) {
+        if (!('updateType' in update) || update.updateType !== 'insert')
+            throw new Error('Expected ORM INSERT DATA serialization');
+        for (const graph of update.insert) {
+            if (graph.type !== 'graph' || graph.name.termType !== 'NamedNode' || graph.name.value !== documentUrl)
+                throw new Error('ORM serialization escaped the Run document');
+            for (const triple of graph.triples) {
+                if (triple.subject.termType !== 'BlankNode' && (triple.subject.termType !== 'NamedNode'
+                    || !(triple.subject.value === iri || triple.subject.value.startsWith(`${iri}/`))))
+                    throw new Error('ORM serialization escaped the Run resource');
+                if (!('termType' in triple.predicate) || triple.predicate.termType !== 'NamedNode'
+                    || triple.object.termType === 'Variable')
+                    throw new Error('Expected concrete RDF triples');
+                output.push(n3_1.DataFactory.quad(triple.subject, triple.predicate, triple.object));
+            }
+        }
+    }
+    return output;
+}
+//# sourceMappingURL=ConditionalResourceDocument.js.map