@divlet/web 0.0.2 → 0.0.4

package/dist/lib/store.js

@@ -1,5 +1,5 @@
 import { clamp } from './util.js';
-import { post, readSession, shareSelection } from './host.js';
+import { readSession, shareSelection, writer } from './host.js';
 export { base, apiUrl, request, post } from './host.js';
 
 const listeners = new Map();
@@ -20,6 +20,9 @@ export const store = {
   leaving: new Set(),
 };
 
+/** A capability is unavailable only when the host says `false`; native hosts predate the newer flags and omit them. */
+export const capable = name => store.state?.project?.capabilities?.[name] !== false;
+
 export const documents = () => (store.state?.documents || []).filter(doc => !store.leaving.has(doc.id));
 export const descriptor = id => documents().find(doc => doc.id === id);
 
@@ -117,10 +120,10 @@ function enqueue(documentId, task) {
   return result;
 }
 
-async function send(route, documentId, build, { version = Math.max(known.get(documentId) || 0, descriptor(documentId)?.version || 0), retry = true } = {}) {
+async function send(write, documentId, build, { version = Math.max(known.get(documentId) || 0, descriptor(documentId)?.version || 0), retry = true } = {}) {
   for (let attempt = 0; ; attempt++) {
     try {
-      const result = await post(route, build(version));
+      const result = await write(build(version));
       known.set(documentId, result.version);
       return result;
     } catch (error) {
@@ -136,32 +139,32 @@ export function commit(documentId, patch, { label, group, expectedVersion, expec
   const guard = expectedVersion === undefined ? {} : { version: expectedVersion, retry: false };
   const format = store.state?.project?.format;
   return enqueue(documentId, async () => {
-    if (typeof patch !== 'function') return send('api/patch', documentId, version => ({ documentId, expectedVersion: version, expectedRender, patch, label, group }), guard);
+    if (typeof patch !== 'function') return send(writer.patch, documentId, version => ({ documentId, expectedVersion: version, expectedRender, patch, label, group }), guard);
     if (store.state?.project?.format !== format) throw Object.assign(new Error('The source format changed. Read it again before retrying.'), { code: 'REVISION_CONFLICT' });
     const model = await freshModel(documentId);
     if (store.state?.project?.format !== format || model !== cachedModel(documentId) || model.version < (known.get(documentId) || 0)) throw Object.assign(new Error('The frame model is not current. Read it again before retrying.'), { code: 'REVISION_CONFLICT' });
     const derived = await patch(model);
     if (store.state?.project?.format !== format || model !== cachedModel(documentId)) throw Object.assign(new Error('The frame changed while preparing this edit. Read it again before retrying.'), { code: 'REVISION_CONFLICT' });
     if (!derived) return null;
-    return send('api/patch', documentId, version => ({ documentId, expectedVersion: version, expectedRender, patch: derived, label, group }), { version: expectedVersion ?? model.version, retry: false });
+    return send(writer.patch, documentId, version => ({ documentId, expectedVersion: version, expectedRender, patch: derived, label, group }), { version: expectedVersion ?? model.version, retry: false });
   }).catch(error => { toast(error.message); throw error; });
 }
 export function edit(documentId, op, { label, group, expectedRender } = {}) {
   const format = store.state?.project?.format;
   return enqueue(documentId, async () => {
-    if (typeof op !== 'function') return send('api/edit', documentId, expectedVersion => ({ documentId, expectedVersion, expectedRender, op, label, group }));
+    if (typeof op !== 'function') return send(writer.edit, documentId, expectedVersion => ({ documentId, expectedVersion, expectedRender, op, label, group }));
     // Derive relative legacy intent after local commits; native operations keep their shown-view guards.
     if (store.state?.project?.format !== format) throw Object.assign(new Error('The source format changed. Read it again before retrying.'), { code: 'REVISION_CONFLICT' });
     const model = await freshModel(documentId);
     if (store.state?.project?.format !== format || model !== cachedModel(documentId) || model.version < (known.get(documentId) || 0)) throw Object.assign(new Error('The frame model is not current. Read it again before retrying.'), { code: 'REVISION_CONFLICT' });
     const derived = op(model);
     if (!derived) return null;
-    return send('api/edit', documentId, expectedVersion => ({ documentId, expectedVersion, expectedRender, op: derived, label, group }), { version: model.version, retry: false });
+    return send(writer.edit, documentId, expectedVersion => ({ documentId, expectedVersion, expectedRender, op: derived, label, group }), { version: model.version, retry: false });
   }).catch(error => { toast(error.message); throw error; });
 }
 
-export const undo = () => post('api/undo', {}).catch(error => { toast(error.message); return null; });
-export const redo = () => post('api/redo', {}).catch(error => { toast(error.message); return null; });
+export const undo = () => writer.undo({}).catch(error => { toast(error.message); return null; });
+export const redo = () => writer.redo({}).catch(error => { toast(error.message); return null; });
 
 /* ---- selection ------------------------------------------------------------ */
 let selectionSequence = 0;

package/dist/lib/webmcp.d.ts

@@ -0,0 +1,34 @@
+import type { ToolRegistry } from './mcp-tools.ts';
+interface WebMcpToolInit {
+    name: string;
+    title?: string;
+    description: string;
+    inputSchema?: object;
+    annotations?: {
+        readOnlyHint?: boolean;
+        consequentialHint?: boolean;
+    };
+    execute(input: object, options: {
+        signal: AbortSignal;
+    }): Promise<unknown>;
+}
+/** The part of the draft's `ModelContext` this adapter uses. */
+export interface WebMcpModelContext {
+    registerTool(tool: WebMcpToolInit, options?: {
+        signal?: AbortSignal;
+    }): Promise<unknown> | unknown;
+}
+/**
+ * Register every tool of `registry` with WebMCP. Resolves to the names that registered (an empty list when the browser has no
+ * `document.modelContext`, for example outside a secure context) and a function that unregisters them. Failures of individual
+ * registrations are reported, never thrown: WebMCP is a compatibility surface, not a requirement.
+ */
+export declare function registerWebMcpTools(registry: ToolRegistry, context?: unknown): Promise<{
+    registered: string[];
+    failed: Array<{
+        name: string;
+        message: string;
+    }>;
+    unregister: () => void;
+}>;
+export {};

package/dist/lib/webmcp.js

@@ -0,0 +1,37 @@
+const isModelContext = (value) => !!value && typeof value.registerTool === 'function';
+/**
+ * Register every tool of `registry` with WebMCP. Resolves to the names that registered (an empty list when the browser has no
+ * `document.modelContext`, for example outside a secure context) and a function that unregisters them. Failures of individual
+ * registrations are reported, never thrown: WebMCP is a compatibility surface, not a requirement.
+ */
+export async function registerWebMcpTools(registry, context = globalThis.document?.modelContext) {
+    const controller = new AbortController();
+    const unregister = () => controller.abort();
+    if (!isModelContext(context))
+        return { registered: [], failed: [], unregister };
+    const registered = [], failed = [];
+    for (const descriptor of registry.descriptors) {
+        const readOnly = descriptor.annotations?.readOnlyHint === true;
+        const init = {
+            name: descriptor.name,
+            ...(descriptor.title ? { title: descriptor.title } : {}),
+            description: descriptor.description,
+            inputSchema: descriptor.inputSchema,
+            annotations: { readOnlyHint: readOnly, consequentialHint: !readOnly && descriptor.annotations?.destructiveHint !== false },
+            async execute(input, options) {
+                const outcome = await registry.run(descriptor.name, input, { signal: options?.signal });
+                if (outcome.ok)
+                    return outcome.value;
+                throw Object.assign(new Error(`${outcome.error.code}: ${outcome.error.message}`), { code: outcome.error.code });
+            },
+        };
+        try {
+            await context.registerTool(init, { signal: controller.signal });
+            registered.push(descriptor.name);
+        }
+        catch (error) {
+            failed.push({ name: descriptor.name, message: String(error?.message || error) });
+        }
+    }
+    return { registered, failed, unregister };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@divlet/web",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "description": "The divlet browser board, static client assets and transport-free host ports",
   "type": "module",
   "license": "MIT",
@@ -24,6 +24,10 @@
     "./host": {
       "divlet-source": "./lib/board-host.ts",
       "default": "./dist/lib/board-host.js"
+    },
+    "./mcp": {
+      "divlet-source": "./lib/mcp-provider.ts",
+      "default": "./dist/lib/mcp-provider.js"
     }
   },
   "files": [