@xopcai/xopc 0.0.253 → 0.0.255

package/dist/src/heartbeat/index.js

@@ -1,6 +1,6 @@
 import { DEFAULT_ACK_MAX_CHARS, HEARTBEAT_OK, NO_REPLY, shouldSilence, stripHeartbeatToken } from "./tokens.js";
-import { appendCronEventLines } from "./event-prompt.js";
 import { isWithinActiveHours } from "./active-hours.js";
 import { isHeartbeatContentEmpty } from "./content-check.js";
+import { appendCronEventLines } from "./event-prompt.js";
 import { createHeartbeatWake } from "./wake.js";
 export { DEFAULT_ACK_MAX_CHARS, HEARTBEAT_OK, NO_REPLY, appendCronEventLines, createHeartbeatWake, isHeartbeatContentEmpty, isWithinActiveHours, shouldSilence, stripHeartbeatToken };

package/dist/src/providers/auth-runtime/resolve-auth.js

@@ -1,5 +1,5 @@
-import { init_sync_provider_auth, resolveProviderApiKeyForAgentSync } from "../../auth/sync-provider-auth.js";
 import { getApiKeyFromEnv, init_env_keys } from "../env-keys.js";
+import { init_sync_provider_auth, resolveProviderApiKeyForAgentSync } from "../../auth/sync-provider-auth.js";
 import { getDefaultAuthProfileStore } from "./auth-profile-store.js";
 //#region src/providers/auth-runtime/resolve-auth.ts
 init_env_keys();

package/dist/src/providers/index.js

@@ -1,11 +1,11 @@
 import { __esmMin, __exportAll } from "../../_virtual/_rolldown/runtime.js";
 import { getAgentDefaultModelRef, init_schema } from "../config/schema.js";
-import { getModelOAuthProviderIds, init_registry } from "../auth/oauth/registry.js";
-import { hasProviderAuthOnDiskSync, init_sync_provider_auth } from "../auth/sync-provider-auth.js";
 import { PROVIDER_ENV_MAP, getApiKeyFromEnv, init_env_keys } from "./env-keys.js";
 import { init_model_ref, splitProviderModelRef } from "./model-ref.js";
 import { ModelRegistry, getModelRegistry, init_model_registry, prewarmModelRegistry, resetModelRegistry } from "./model-registry.js";
+import { getModelOAuthProviderIds, init_registry } from "../auth/oauth/registry.js";
 import { CredentialResolver, hasCredentials, init_credentials } from "../auth/credentials.js";
+import { hasProviderAuthOnDiskSync, init_sync_provider_auth } from "../auth/sync-provider-auth.js";
 import { EXTENSION_PROVIDER_BASE_URL, init_constants } from "./constants.js";
 import { applyOfficialModelMetadataCorrections, getSupplementalModels, init_model_supplements } from "./model-supplements.js";
 import { getProviderRegistry, init_plugin_registry } from "./plugin-registry.js";

package/dist/src/providers/model-registry.js

@@ -1,8 +1,8 @@
 import { __esmMin } from "../../_virtual/_rolldown/runtime.js";
 import { createLogger } from "../utils/logger/index.js";
 import { init_logger } from "../utils/logger.js";
-import { resolveModelsJsonPath } from "../config/paths.js";
 import { init_resolve_config_value, resolveConfigValue, resolveHeaders } from "../config/resolve-config-value.js";
+import { resolveModelsJsonPath } from "../config/paths.js";
 import { getDefaultModelValues, init_models_json, validateModelsConfig } from "../config/models-json.js";
 import { getApiKeyFromEnv, init_env_keys } from "./env-keys.js";
 import { getModelCatalogStore, init_model_catalog_store } from "./model-catalog-store.js";

package/dist/src/providers/model-thinking.js

@@ -1,5 +1,18 @@
 import { getSupportedThinkingLevels } from "@earendil-works/pi-ai";
 //#region src/providers/model-thinking.ts
+const TOGGLE_THINKING_FORMATS = new Set([
+	"zai",
+	"qwen",
+	"qwen-chat-template",
+	"chat-template",
+	"deepseek",
+	"together",
+	"baseten",
+	"string-thinking"
+]);
+function preferredEnabledLevel(options) {
+	return options.includes("high") ? "high" : options.find((option) => option !== "off");
+}
 /** Use the same capability metadata as the provider runtime. */
 function getModelThinking(model) {
 	const base = { supportsAdaptive: false };
@@ -10,29 +23,53 @@ function getModelThinking(model) {
 		initialValue: "off"
 	};
 	const compat = model.compat;
-	const binaryFormat = [
-		"zai",
-		"qwen",
-		"qwen-chat-template",
-		"chat-template"
-	].includes(compat?.thinkingFormat ?? "");
-	const binaryProvider = model.provider === "zai" || model.provider === "z.ai";
-	if ((binaryFormat || binaryProvider) && compat?.supportsReasoningEffort !== true) return {
-		...base,
-		mode: "toggle",
-		options: ["off", "high"],
-		initialValue: "high"
-	};
-	if (compat?.supportsReasoningEffort === false) return {
-		...base,
-		mode: "unknown",
-		options: ["off"],
-		initialValue: "off"
-	};
 	const options = getSupportedThinkingLevels(model);
+	const enabledLevel = preferredEnabledLevel(options);
+	if ((TOGGLE_THINKING_FORMATS.has(compat?.thinkingFormat ?? "") || model.provider === "zai" || model.provider === "z.ai") && compat?.supportsReasoningEffort !== true && enabledLevel) {
+		if (options.includes("off")) return {
+			...base,
+			mode: "toggle",
+			options: ["off", enabledLevel],
+			initialValue: enabledLevel
+		};
+		return {
+			...base,
+			mode: "fixed",
+			options: [enabledLevel],
+			initialValue: enabledLevel
+		};
+	}
+	if (compat?.supportsReasoningEffort === false) {
+		if (enabledLevel) return {
+			...base,
+			mode: "fixed",
+			options: [enabledLevel],
+			initialValue: enabledLevel
+		};
+		return {
+			...base,
+			mode: "none",
+			options: ["off"],
+			initialValue: "off"
+		};
+	}
+	if (options.length === 1) {
+		const only = options[0] ?? "off";
+		return only === "off" ? {
+			...base,
+			mode: "none",
+			options: ["off"],
+			initialValue: "off"
+		} : {
+			...base,
+			mode: "fixed",
+			options: [only],
+			initialValue: only
+		};
+	}
 	return {
 		...base,
-		mode: options.length > 1 ? "levels" : "none",
+		mode: "levels",
 		options,
 		initialValue: options.includes("medium") ? "medium" : options[0] ?? "off"
 	};

package/dist/src/providers/register-runtime-providers.js

@@ -1,6 +1,6 @@
 import { __esmMin } from "../../_virtual/_rolldown/runtime.js";
-import { getOAuthProviderDefinition, init_registry } from "../auth/oauth/registry.js";
 import { getModelCatalogStore, init_model_catalog_store } from "./model-catalog-store.js";
+import { getOAuthProviderDefinition, init_registry } from "../auth/oauth/registry.js";
 import { XOPC_CLOUD_PROVIDER_ID, init_xopc_cloud_config, resolveXopcModelRouterUrl } from "./xopc-cloud-config.js";
 //#region src/providers/register-runtime-providers.ts
 function registerRuntimeProvider(modelRuntime, source) {

package/dist/src/remote-access/exposure-manager.js

@@ -2,9 +2,9 @@ import { createLogger } from "../utils/logger/index.js";
 import { init_logger } from "../utils/logger.js";
 import { isTailscaleInstalled } from "../infra/tailscale.js";
 import { resolveGatewayBindMode } from "../config/gateway-bind.js";
+import { getTunnelService } from "../tunnel/tunnel-service.js";
 import { collectExposureConflicts } from "./exposure-guards.js";
 import { getTailscaleExposureState, maybeStartTailscaleFromConfig, stopTailscaleExposure } from "../gateway/tailscale-lifecycle.js";
-import { getTunnelService } from "../tunnel/tunnel-service.js";
 import { getTunnelConsentState } from "../tunnel/consent.js";
 import { maybeAutoStartTunnelFromConfig } from "../tunnel/gateway-lifecycle.js";
 //#region src/remote-access/exposure-manager.ts

package/dist/src/session/index.js

@@ -1,9 +1,9 @@
 import { buildSessionContextForLlm, isTranscriptContextEntry, mergeLlmMessagesPreservingContextRows, transcriptRowsFromJsonArray } from "./session-context-for-llm.js";
 import { SessionStatus } from "./types.js";
 import { effectiveWorkspacePathForSession, normalizeWorkingDirectoryInput, projectWorkspacePath } from "./session-workspace.js";
+import { flattenMessageContent, messagesToClientHistory } from "./client-history.js";
 import { emitSessionTranscriptUpdate, onSessionTranscriptUpdate } from "./transcript-events.js";
 import { fallbackTitleFromMessages, generateSessionTitleFromMessages, getSessionTitleSource, isWebchatSessionKey, maybeRefineSessionTitleWithLlm, maybeSetProvisionalSessionTitle, provisionalTitleFromUserText, sanitizeGeneratedSessionTitle, sanitizeSessionTitle, shouldAutoTitleSessionKey, shouldRefineSessionTitleWithLlm } from "./session-title.js";
-import { flattenMessageContent, messagesToClientHistory } from "./client-history.js";
 import { SessionStore } from "./store.js";
 import { applySessionPatchToMetadata } from "./patch-metadata.js";
 import { SessionIndex } from "./manager.js";

package/dist/src/session/store.js

@@ -12,6 +12,7 @@ import { appendCompactionBoundaryIfUnchanged, appendTranscriptEntry, listCompact
 import { getSessionConfig, setSessionConfig } from "../storage/sqlite/config-repository.js";
 import "../storage/sqlite/index.js";
 import { resolveEffectiveAgentProfileForSession } from "../config/agent-profile.js";
+import { transcriptRowsToClientHistory } from "./client-history.js";
 import { SessionCompactor } from "../agent/memory/compaction.js";
 import { resolveUserContextSessionAccess } from "../user-context/access-policy.js";
 import { readPostCompactionContext } from "../agent/reply/post-compaction-context.js";
@@ -19,7 +20,6 @@ import { resolveCompactionPolicy } from "../agent/memory/compaction-policy.js";
 import { promoteCompactionLedger } from "../agent/memory/compaction-promotion.js";
 import { SlidingWindow } from "../agent/memory/window.js";
 import { isAppendOnlyLlmTranscriptMessage } from "./transcript-stats.js";
-import { transcriptRowsToClientHistory } from "./client-history.js";
 import { backfillStructuredTurnOutcomes } from "./turn-outcome-projector.js";
 import { computeTranscriptUserRoundDeleteRange } from "./user-round-delete.js";
 //#region src/session/store.ts

package/dist/src/share/hosted-note-publication.d.ts

@@ -0,0 +1,22 @@
+import type { HostedPublicationSnapshot } from './hosted-session-share.js';
+import { type NoteShareSource } from './note-share-service.js';
+export interface HostedNotePublicationSnapshot extends HostedPublicationSnapshot {
+    kind: 'note_document';
+    sourceNoteId: string;
+    sourceVersion: number;
+    title: string;
+    attachmentCount: number;
+}
+export declare class HostedNotePublicationBuilder {
+    private readonly notes;
+    constructor(notes: NoteShareSource);
+    build(noteId: string, input: {
+        expectedNoteVersion?: number;
+        attachmentIds?: string[];
+        description?: string;
+    }): Promise<HostedNotePublicationSnapshot>;
+}
+export declare class HostedNoteVersionConflictError extends Error {
+    readonly currentVersion: number;
+    constructor(currentVersion: number);
+}

package/dist/src/share/hosted-note-publication.js

@@ -0,0 +1,96 @@
+import { collectReferencedAttachmentIds } from "../notes/note-attachment-sync.js";
+import { projectPublicNoteMarkdown } from "./note-share-service.js";
+import { createReadStream } from "node:fs";
+import { createHash } from "node:crypto";
+import { stat } from "node:fs/promises";
+//#region src/share/hosted-note-publication.ts
+const MAX_ATTACHMENTS = 20;
+const MAX_ATTACHMENT_BYTES = 32 * 1024 * 1024;
+const MAX_TOTAL_BYTES = 100 * 1024 * 1024;
+const MAX_MARKDOWN_BYTES = 5 * 1024 * 1024;
+var HostedNotePublicationBuilder = class {
+	constructor(notes) {
+		this.notes = notes;
+	}
+	async build(noteId, input) {
+		const note = await this.notes.getNote(noteId);
+		if (!note) throw new Error("Note not found");
+		if (input.expectedNoteVersion !== void 0 && note.updatedAt !== input.expectedNoteVersion) throw new HostedNoteVersionConflictError(note.updatedAt);
+		const referenced = collectReferencedAttachmentIds(note);
+		const attachments = new Map((note.attachments ?? []).map((attachment) => [attachment.id, attachment]));
+		for (const id of referenced) if (!attachments.has(id)) throw new Error(`Referenced attachment is missing: ${id}`);
+		const selected = input.attachmentIds === void 0 ? [...referenced] : [...new Set(input.attachmentIds)];
+		if (selected.length > MAX_ATTACHMENTS) throw new Error("Note has too many attachments to publish");
+		for (const id of selected) if (!referenced.has(id)) throw new Error(`Attachment is not referenced by this Note: ${id}`);
+		const selectedSet = new Set(selected);
+		const markdown = rewritePublicationAssets(projectPublicNoteMarkdown(note, selectedSet), note, selectedSet);
+		if (Buffer.byteLength(markdown, "utf8") > MAX_MARKDOWN_BYTES) throw new Error("Note Markdown exceeds publishing limit");
+		const assets = [];
+		const manifestAttachments = [];
+		let totalBytes = Buffer.byteLength(markdown, "utf8");
+		for (const id of selected) {
+			const attachment = attachments.get(id);
+			if (attachment.size > MAX_ATTACHMENT_BYTES) throw new Error(`Attachment exceeds publishing limit: ${attachment.fileName}`);
+			totalBytes += attachment.size;
+			if (totalBytes > MAX_TOTAL_BYTES) throw new Error("Note publication exceeds total size limit");
+			const resolved = await this.notes.getAttachmentPath(note.id, id);
+			if (!resolved) throw new Error(`Attachment is missing: ${attachment.fileName}`);
+			const current = await stat(resolved.filePath);
+			if (!current.isFile() || current.size !== attachment.size) throw new Error(`Attachment changed or is missing: ${attachment.fileName}`);
+			assets.push({
+				id,
+				path: resolved.filePath,
+				size: attachment.size
+			});
+			manifestAttachments.push({
+				id,
+				fileName: attachment.fileName,
+				mimeType: attachment.mimeType,
+				size: attachment.size,
+				sha256: await sha256File(resolved.filePath)
+			});
+		}
+		return {
+			kind: "note_document",
+			sourceNoteId: note.id,
+			sourceVersion: note.updatedAt,
+			title: note.title?.trim() || "Untitled Note",
+			attachmentCount: assets.length,
+			assets,
+			manifest: {
+				schemaVersion: 1,
+				kind: "note_document",
+				title: note.title?.trim() || "Untitled Note",
+				snapshotAt: (/* @__PURE__ */ new Date()).toISOString(),
+				...input.description?.trim() ? { description: input.description.trim() } : {},
+				markdown,
+				attachments: manifestAttachments
+			}
+		};
+	}
+};
+var HostedNoteVersionConflictError = class extends Error {
+	constructor(currentVersion) {
+		super("Note changed after the publication preview was reviewed");
+		this.currentVersion = currentVersion;
+		this.name = "HostedNoteVersionConflictError";
+	}
+};
+function rewritePublicationAssets(markdown, note, selected) {
+	return markdown.replace(/xopc-attachment:\/\/notes\/([^/\s)]+)\/([^\s)]+)/gi, (match, rawNoteId, rawAttachmentId) => {
+		try {
+			const noteId = decodeURIComponent(rawNoteId);
+			const attachmentId = decodeURIComponent(rawAttachmentId);
+			return noteId === note.id && selected.has(attachmentId) ? `xopc-publication-asset://${attachmentId}` : match;
+		} catch {
+			return match;
+		}
+	});
+}
+async function sha256File(filePath) {
+	const hash = createHash("sha256");
+	for await (const chunk of createReadStream(filePath)) hash.update(chunk);
+	return hash.digest("hex");
+}
+//#endregion
+export { HostedNotePublicationBuilder, HostedNoteVersionConflictError };

package/dist/src/share/hosted-session-share.d.ts

@@ -3,6 +3,7 @@ import { type SessionShareMessage, type SessionShareToolActivity } from './sessi
 import { type SessionShareSource } from './session-share-service.js';
 export interface HostedSessionShareManifest {
     schemaVersion: 1;
+    kind: 'session_document';
     title: string;
     snapshotAt: string;
     description?: string;
@@ -49,7 +50,17 @@ export interface HostedShareResult {
     viewCount: number;
     snapshotRevision: number;
 }
-type OwnerShare = {
+export type HostedPublicationKind = 'session_document' | 'note_document' | 'static_site';
+export interface HostedPublicationSnapshot {
+    kind: HostedPublicationKind;
+    manifest: unknown;
+    assets: Array<{
+        id: string;
+        path: string;
+        size: number;
+    }>;
+}
+export type HostedPublicationSummary = {
     id: string;
     title: string;
     description: string | null;
@@ -60,8 +71,42 @@ type OwnerShare = {
     viewCount: number;
     createdAt: string;
     updatedAt: string;
+    kind: HostedPublicationKind;
+    deliveryMode: 'hosted_snapshot';
+    owner: {
+        type: 'user' | 'workspace';
+        id: string;
+    };
+    workspaceId: string;
+    createdByPrincipalId: string;
 };
-export declare class HostedSessionSharePublisher {
+type OwnerShare = HostedPublicationSummary;
+export interface HostedPublicationCapabilities {
+    protocolVersion: string;
+    kinds: string[];
+    deliveryModes: string[];
+    accessModes: string[];
+    upload: {
+        direct: boolean;
+        multipart: boolean;
+        resumable: boolean;
+        streaming: boolean;
+    };
+    security?: {
+        contentScanning: boolean;
+        quarantineBeforeActivation: boolean;
+    };
+    lifecycle: {
+        revisions: boolean;
+        revoke: boolean;
+        asynchronousDeletion: boolean;
+    };
+    publishing: {
+        allowed: boolean;
+        managedBy: 'platform_admin';
+    };
+}
+export declare class HostedPublicationPublisher {
     private readonly credentials;
     private readonly fetchImpl;
     private readonly baseUrl;
@@ -70,23 +115,54 @@ export declare class HostedSessionSharePublisher {
         ttlMs: number;
         maxViews: number | null;
     }): Promise<HostedShareResult>;
+    createPublication(snapshot: HostedPublicationSnapshot, lifecycle: {
+        ttlMs: number;
+        maxViews: number | null;
+    }): Promise<HostedShareResult>;
     refresh(shareId: string, expectedRevision: number, publicUrl: string, snapshot: HostedSessionShareSnapshot): Promise<HostedShareResult>;
-    list(): Promise<OwnerShare[]>;
+    refreshPublication(shareId: string, expectedRevision: number, publicUrl: string, snapshot: HostedPublicationSnapshot): Promise<HostedShareResult>;
+    listPublications(): Promise<HostedPublicationSummary[]>;
+    capabilities(): Promise<HostedPublicationCapabilities>;
     revoke(shareId: string): Promise<void>;
+    revokePublication(shareId: string): Promise<void>;
+    listRevisions(shareId: string): Promise<Array<{
+        revision: number;
+        createdAt: string;
+        current: boolean;
+    }>>;
+    rollbackPublication(shareId: string, expectedRevision: number, targetRevision: number): Promise<HostedPublicationSummary>;
     private uploadAssets;
     private request;
 }
 export declare class HostedShareAuthorizationError extends Error {
     constructor();
 }
+export declare class HostedShareRemoteError extends Error {
+    readonly status: number;
+    readonly code?: string;
+    constructor(message: string, status: number, code?: string);
+}
+export type HostedPublicationSource = {
+    kind: 'session' | 'note' | 'static_site';
+    id: string;
+    version: string;
+};
 export interface HostedShareBinding extends HostedShareResult {
-    sessionId: string;
-    cutoffSeq: number;
+    kind: HostedPublicationKind;
+    source: HostedPublicationSource;
+    revisionSources: Record<string, HostedPublicationSource>;
+    workspaceContext?: {
+        workspaceRoot?: string;
+        sessionKey?: string;
+        agentId?: string;
+    };
+    sessionId?: string;
+    cutoffSeq?: number;
     title: string;
     description: string | null;
-    messageCount: number;
+    messageCount?: number;
     attachmentCount: number;
-    includeToolActivities: boolean;
+    includeToolActivities?: boolean;
     attachmentIds: string[];
     createdAt: string;
     updatedAt: string;
@@ -95,7 +171,10 @@ export interface HostedShareBinding extends HostedShareResult {
 export declare class HostedShareBindingStore {
     private readonly state;
     list(sessionId: string): Promise<HostedShareBinding[]>;
+    listBySource(kind: HostedPublicationSource['kind'], id: string): Promise<HostedShareBinding[]>;
+    listAll(): Promise<HostedShareBinding[]>;
     upsert(binding: HostedShareBinding): Promise<void>;
+    markRevoked(id: string): Promise<void>;
     reconcile(remote: OwnerShare[]): Promise<void>;
 }
 export {};

package/dist/src/share/hosted-session-share.js

@@ -9,7 +9,7 @@ import { SessionShareSnapshotConflictError } from "./session-share-service.js";
 import { basename } from "node:path";
 import { createReadStream } from "node:fs";
 import { createHash, randomBytes, randomUUID } from "node:crypto";
-import { readFile, stat } from "node:fs/promises";
+import { stat } from "node:fs/promises";
 //#region src/share/hosted-session-share.ts
 init_credentials();
 init_resolution();
@@ -82,6 +82,7 @@ var HostedSessionShareBuilder = class {
 			cutoffSeq: source.snapshot.lastSeq,
 			manifest: {
 				schemaVersion: 1,
+				kind: "session_document",
 				title: (source.metadata.name?.trim() || "Shared conversation").slice(0, 200),
 				snapshotAt: (/* @__PURE__ */ new Date()).toISOString(),
 				...input.description?.trim() ? { description: input.description.trim().slice(0, 1e3) } : {},
@@ -105,7 +106,7 @@ var HostedSessionShareBuilder = class {
 		};
 	}
 };
-var HostedSessionSharePublisher = class {
+var HostedPublicationPublisher = class {
 	baseUrl;
 	constructor(baseUrl = process.env.XOPC_SHARE_URL ?? resolveConnectedPlatformEndpoint("shareApi") ?? DEFAULT_SHARE_URL, credentials = new CredentialResolver(), fetchImpl = fetch) {
 		this.credentials = credentials;
@@ -113,23 +114,38 @@ var HostedSessionSharePublisher = class {
 		this.baseUrl = baseUrl.replace(/\/+$/, "");
 	}
 	async create(snapshot, lifecycle) {
+		return this.createPublication({
+			kind: "session_document",
+			manifest: snapshot.manifest,
+			assets: snapshot.assets
+		}, lifecycle);
+	}
+	async createPublication(snapshot, lifecycle) {
 		const publicToken = randomBytes(32).toString("base64url");
-		const draft = await this.request("/api/v1/session-shares", {
+		const draft = await this.request("/api/v1/publications", {
 			method: "POST",
 			headers: { "Idempotency-Key": `xopc-${randomUUID()}` },
 			body: JSON.stringify({
+				kind: snapshot.kind,
 				publicToken,
 				manifest: snapshot.manifest,
 				...lifecycle
 			})
 		});
 		await this.uploadAssets(draft, snapshot.assets);
-		const finalized = await this.request(`/api/v1/session-shares/${encodeURIComponent(draft.shareId)}/uploads/${encodeURIComponent(draft.uploadId)}/finalize`, { method: "POST" });
+		const finalized = await this.request(`/api/v1/publications/${encodeURIComponent(draft.shareId)}/uploads/${encodeURIComponent(draft.uploadId)}/finalize`, { method: "POST" });
 		if (!draft.publicUrl) throw new Error("Hosted Share did not return a public URL");
 		return toResult(finalized.item, draft.publicUrl);
 	}
 	async refresh(shareId, expectedRevision, publicUrl, snapshot) {
-		const draft = await this.request(`/api/v1/session-shares/${encodeURIComponent(shareId)}/revisions`, {
+		return this.refreshPublication(shareId, expectedRevision, publicUrl, {
+			kind: "session_document",
+			manifest: snapshot.manifest,
+			assets: snapshot.assets
+		});
+	}
+	async refreshPublication(shareId, expectedRevision, publicUrl, snapshot) {
+		const draft = await this.request(`/api/v1/publications/${encodeURIComponent(shareId)}/revisions`, {
 			method: "POST",
 			headers: { "Idempotency-Key": `xopc-${randomUUID()}` },
 			body: JSON.stringify({
@@ -138,28 +154,47 @@ var HostedSessionSharePublisher = class {
 			})
 		});
 		await this.uploadAssets(draft, snapshot.assets);
-		return toResult((await this.request(`/api/v1/session-shares/${encodeURIComponent(shareId)}/uploads/${encodeURIComponent(draft.uploadId)}/finalize`, { method: "POST" })).item, publicUrl);
+		return toResult((await this.request(`/api/v1/publications/${encodeURIComponent(shareId)}/uploads/${encodeURIComponent(draft.uploadId)}/finalize`, { method: "POST" })).item, publicUrl);
 	}
-	async list() {
-		return (await this.request("/api/v1/session-shares")).items;
+	async listPublications() {
+		return (await this.request("/api/v1/publications")).items;
+	}
+	async capabilities() {
+		return this.request("/api/v1/publications/capabilities");
 	}
 	async revoke(shareId) {
-		await this.request(`/api/v1/session-shares/${encodeURIComponent(shareId)}`, { method: "DELETE" });
+		await this.revokePublication(shareId);
+	}
+	async revokePublication(shareId) {
+		await this.request(`/api/v1/publications/${encodeURIComponent(shareId)}`, { method: "DELETE" });
+	}
+	async listRevisions(shareId) {
+		return (await this.request(`/api/v1/publications/${encodeURIComponent(shareId)}/revisions`)).items;
+	}
+	async rollbackPublication(shareId, expectedRevision, targetRevision) {
+		return (await this.request(`/api/v1/publications/${encodeURIComponent(shareId)}/rollback`, {
+			method: "POST",
+			body: JSON.stringify({
+				expectedRevision,
+				targetRevision
+			})
+		})).item;
 	}
 	async uploadAssets(draft, assets) {
 		const uploads = new Map(draft.assetUploads.map((upload) => [upload.assetId, upload.uploadUrl]));
 		for (const asset of assets) {
 			const uploadUrl = uploads.get(asset.id);
 			if (!uploadUrl) throw new Error(`Hosted Share did not accept attachment: ${asset.id}`);
-			const bytes = await readFile(asset.path);
-			if (bytes.byteLength !== asset.size) throw new Error(`Attachment changed during upload: ${asset.id}`);
+			const current = await stat(asset.path);
+			if (!current.isFile() || current.size !== asset.size) throw new Error(`Attachment changed during upload: ${asset.id}`);
 			await this.request(uploadUrl, {
 				method: "PUT",
 				headers: {
-					"Content-Length": String(bytes.byteLength),
+					"Content-Length": String(asset.size),
 					"Content-Type": "application/octet-stream"
 				},
-				body: bytes
+				body: createReadStream(asset.path),
+				duplex: "half"
 			});
 		}
 	}
@@ -180,7 +215,7 @@ var HostedSessionSharePublisher = class {
 		});
 		const body = await response.json().catch(() => ({}));
 		if (response.status === 401) throw new HostedShareAuthorizationError();
-		if (!response.ok) throw new Error(body.error?.message || `Hosted Share request failed (${response.status})`);
+		if (!response.ok) throw new HostedShareRemoteError(body.error?.message || `Hosted Share request failed (${response.status})`, response.status, body.error?.code);
 		return body;
 	}
 };
@@ -190,14 +225,36 @@ var HostedShareAuthorizationError = class extends Error {
 		this.name = "HostedShareAuthorizationError";
 	}
 };
+var HostedShareRemoteError = class extends Error {
+	constructor(message, status, code) {
+		super(message);
+		this.status = status;
+		this.code = code;
+		this.name = "HostedShareRemoteError";
+	}
+};
 var HostedShareBindingStore = class {
 	state = new DurableState("hosted-share-bindings");
 	async list(sessionId) {
 		return this.state.values().filter((item) => item.sessionId === sessionId).sort((a, b) => b.createdAt.localeCompare(a.createdAt));
 	}
+	async listBySource(kind, id) {
+		return this.state.values().filter((item) => item.source.kind === kind && item.source.id === id).sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+	}
+	async listAll() {
+		return this.state.values().sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+	}
 	async upsert(binding) {
 		this.state.set(binding.id, binding);
 	}
+	async markRevoked(id) {
+		const binding = this.state.get(id);
+		if (binding) this.state.set(id, {
+			...binding,
+			revoked: true,
+			updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+		});
+	}
 	async reconcile(remote) {
 		const byId = new Map(remote.map((item) => [item.id, item]));
 		requireXopcDatabase();
@@ -242,4 +299,4 @@ async function checksumFile(path) {
 	return hash.digest("hex");
 }
 //#endregion
-export { HostedSessionShareBuilder, HostedSessionSharePublisher, HostedShareAuthorizationError, HostedShareBindingStore };
+export { HostedPublicationPublisher, HostedSessionShareBuilder, HostedShareAuthorizationError, HostedShareBindingStore, HostedShareRemoteError };

package/dist/src/share/hosted-static-site-publication.d.ts

@@ -0,0 +1,16 @@
+import type { HostedPublicationSnapshot } from './hosted-session-share.js';
+export interface HostedStaticSitePublicationSnapshot extends HostedPublicationSnapshot {
+    kind: 'static_site';
+    rootDir: string;
+    title: string;
+    fileCount: number;
+    totalBytes: number;
+}
+export declare class HostedStaticSitePublicationBuilder {
+    build(workspaceRoot: string, input: {
+        path: string;
+        title?: string;
+        description?: string;
+        spaFallback?: boolean;
+    }): Promise<HostedStaticSitePublicationSnapshot>;
+}