@panphora/clayjs 1.15.2 → 1.17.0

package/src/server/rooms/page-admission.js

@@ -3,6 +3,9 @@ import { parseJsonRelaxed } from 'hyper-morph/json-parse';
 import { cloneJson } from './live-data-ops.js';
 import { liveTags } from './live-data-tags.js';
 import { recent } from './recent.js';
+import { project } from '../../page/projection.js';
+import { blocksFromPageValues } from '../../page/ybind/decode.js';
+import { pageFormatDecision, pageFormatFloor, pageFormatRefusal, requiredPageFormat, withPageFormatFloor } from '../../page/format-level.js';
 
 const PAGE = /^page(\.[0-9]+)?$/;
 const PART = /^(.+)\.(\d+)\.(\d+)$/;
@@ -77,3 +80,33 @@ export function pageBaseline(tags) {
   });
   return createHash('sha256').update(canon(source), 'utf8').digest('hex');
 }
+
+// The floor a prospective page value needs: 1 when the model the capture would
+// store holds a newer runtime's mark, block or field, 0 when it holds only what
+// the frozen floor-0 registry knows. Invalid content refuses here rather than
+// answering with a level, so a malformed capture cannot buy admission.
+export function captureFormat(html) {
+  const answer = inspectPage(html ?? '');
+  if (answer.kind !== 'yjs') return 0;
+  return requiredPageFormat(project(blocksFromPageValues([answer.tags[0][1]])));
+}
+
+// The floor decision for one page write, taken before anything is mutated.
+// `floor` is the document's established floor, `required` what the captured
+// content needs (its own marker included) and `capability` what the writer
+// declares in X-Clay-Page-Format. `admitted` lists the capabilities of the page
+// editors the room has admitted, so a floor rise is refused while an editor that
+// could not read the result is connected. On success the returned body carries
+// the marker the room must persist, so a stale save that omitted it cannot lower
+// the floor.
+export function checkPageFormatAdmission({ currentHtml, html, capability = 0, admitted = [] }) {
+  const established = pageFormatFloor(currentHtml ?? '');
+  const decision = pageFormatDecision({
+    floor: established,
+    required: Math.max(captureFormat(html), pageFormatFloor(html ?? '')),
+    capability,
+    admitted,
+  });
+  if (!decision.ok) throw pageFormatRefusal(decision.minimum);
+  return { ...decision, html: withPageFormatFloor(html, decision.floor) };
+}

package/src/server/rooms/page-lineage.js

@@ -0,0 +1,56 @@
+import { load } from 'cheerio';
+import * as Y from '../../vendor/yjs.vendor.js';
+import { docFromValue } from '../../page/ybind/provider.js';
+import { seedLineage, seedOnly, sharesLineage } from '../../page/ybind/lineage.js';
+import { inspectPage } from './page-admission.js';
+import { PageConversionError } from './page-conversion.js';
+import { pageArticles, splitPage, inert } from './page-state.js';
+
+const refuse = (reason) => { throw new PageConversionError(reason); };
+const lineages = new Map();
+
+function storedArticle(html, doc) {
+  const $ = load(html);
+  const nodes = $('article[data-page]').toArray().filter((node) => !inert(node));
+  if (nodes.length !== 1) return null;
+  const article = doc.createElement('article');
+  for (const [name, value] of Object.entries(nodes[0].attribs)) article.setAttribute(name, value);
+  article.innerHTML = $(nodes[0]).html();
+  return article;
+}
+
+function storedLineage(html, createDocument) {
+  if (typeof html !== 'string' || pageArticles(html) !== 1) return null;
+  if (lineages.has(html)) return lineages.get(html);
+  if (typeof createDocument !== 'function') throw new TypeError('A first write over a page document needs createDocument');
+  const article = storedArticle(html, createDocument());
+  if (!article) refuse('seed-lineage');
+  const lineage = seedLineage(article);
+  lineages.set(html, lineage);
+  if (lineages.size > 4) lineages.delete(lineages.keys().next().value);
+  return lineage;
+}
+
+export function checkInitialLineage({ currentHtml, html, pageWrite = null, createDocument }) {
+  const lineage = storedLineage(currentHtml, createDocument);
+  if (!lineage) return;
+  let doc;
+  try {
+    doc = docFromValue(inspectPage(html).tags[0][1], { strict: true });
+  } catch {
+    refuse('invalid-capture');
+  }
+  try {
+    if (lineage.client !== null && !Y.decodeStateVector(Y.encodeStateVector(doc)).has(lineage.client)) refuse('seed-lineage');
+    if (typeof pageWrite === 'string' && pageWrite.trim() === 'v1' && seedOnly(doc, lineage.client) &&
+      splitPage(html).file === currentHtml) refuse('nothing-to-write');
+  } finally {
+    doc.destroy();
+  }
+}
+
+export function checkOrdinaryLineage({ currentHtml, html, room = null }) {
+  const before = inspectPage(currentHtml ?? '');
+  const stored = before.kind === 'yjs' ? before.tags[0][1] : room?.stores.get('page')?.value ?? null;
+  if (stored && !sharesLineage(stored, inspectPage(html).tags[0][1])) refuse('seed-lineage');
+}

package/src/server/rooms/page-rebase.js

@@ -5,10 +5,11 @@ import { project, parseModel, renderModel, fragmentCleaner } from '../../page/pr
 import { blocksFromPageValues } from '../../page/ybind/decode.js';
 import { mergePageModels } from '../../page/merge.js';
 import { inert, pageRev } from './page-state.js';
+import { pageFormatFloor, withPageFormatFloor } from '../../page/format-level.js';
 
 // The lone article of html: its element rebuilt in doc, and where its start tag
 // and its contents sit in html.
-function articleOf(html, doc) {
+export function articleOf(html, doc) {
   const $ = load(html, { sourceCodeLocationInfo: true });
   const nodes = $('article[data-page]').toArray().filter((node) => !inert(node));
   if (nodes.length !== 1) return null;
@@ -66,7 +67,10 @@ export function rebasePage({ storedHtml, state, incomingHtml, baseHtml, createDo
   const inner = `\n${renderModel(merged.items, { fallbackOf, clean: fragmentCleaner(doc) })}\n`;
   const [innerStart, innerEnd] = incoming.inner;
   const open = stampOpen(incomingHtml, incoming.startTag, state.rev);
-  const html = incomingHtml.slice(0, incoming.startTag.startOffset) + open + inner + incomingHtml.slice(innerEnd);
+  const body = incomingHtml.slice(0, incoming.startTag.startOffset) + open + inner + incomingHtml.slice(innerEnd);
+  // The floor is canonical metadata outside the article, and it only rises: a
+  // writer that rebased from a version before activation cannot lower it.
+  const html = withPageFormatFloor(body, Math.max(pageFormatFloor(storedHtml), pageFormatFloor(incomingHtml)));
   return { html, conflicts: merged.conflicts };
 }
 
@@ -96,13 +100,15 @@ export function closestBase(candidates, incomingHtml, createDocument) {
 }
 
 // The page document with its article stamped with rev: a version restored as an
-// edit carries the stored rev, so open tabs merge it onto the page they have.
-export function stampPageRev(html, rev) {
+// edit carries the stored rev, so open tabs merge it onto the page they have. A
+// restore is a trusted internal write, so it declares the floor it restores at
+// and the restored document cannot lose an established marker on the way.
+export function stampPageRev(html, rev, floor = 0) {
   if (typeof html !== 'string' || !rev) return null;
   const $ = load(html, { sourceCodeLocationInfo: true });
   const nodes = $('article[data-page]').toArray().filter((node) => !inert(node));
   const loc = nodes.length === 1 ? nodes[0].sourceCodeLocation?.startTag : null;
   if (!loc) return null;
   const stamped = stampOpen(html, loc, rev);
-  return html.slice(0, loc.startOffset) + stamped + html.slice(loc.endOffset);
+  return withPageFormatFloor(html.slice(0, loc.startOffset) + stamped + html.slice(loc.endOffset), floor);
 }

package/src/server/rooms/page-state.js

@@ -27,6 +27,8 @@ const locate = recent(4, (html) => {
   });
 });
 
+export const pageArticles = (html) => locate(html).articles;
+
 export function pageRev(html) {
   if (typeof html !== 'string') return null;
   return locate(html).rev;

package/src/server/rooms/page-write-admission.js

@@ -4,6 +4,7 @@ import { inspectPage } from './page-admission.js';
 import { checkPageConversion, PageConversionError } from './page-conversion.js';
 import { PageFormatError } from './page-write-guard.js';
 import { ifMatchSatisfied } from './spec-wire.js';
+import { checkInitialLineage, checkOrdinaryLineage } from './page-lineage.js';
 
 const PAGE = /^page(\.[0-9]+)?$/;
 const record = (value) => value !== null && typeof value === 'object' && !Array.isArray(value);
@@ -33,14 +34,15 @@ function checkInitialCondition(ifMatch, currentHtml) {
     !ifMatchSatisfied(ifMatch, currentHtml)) refuse('file-changed');
 }
 
-export function checkPageInitial({ currentHtml, html, ifMatch, room = null }) {
+export function checkPageInitial({ currentHtml, html, ifMatch, room = null, pageWrite = null, createDocument }) {
   if (typeof currentHtml !== 'string' || inspectPage(currentHtml).kind !== 'none') refuse('invalid-source');
   if (typeof html !== 'string' || inspectPage(html).kind !== 'yjs') refuse('invalid-capture');
   checkInitialRoom(room);
   checkInitialCondition(ifMatch, currentHtml);
+  checkInitialLineage({ currentHtml, html, pageWrite, createDocument });
 }
 
-export function checkPageWriteAdmission({ currentHtml, html, header = null, ifMatch, room = null }) {
+export function checkPageWriteAdmission({ currentHtml, html, header = null, ifMatch, room = null, pageWrite = null, createDocument }) {
   const before = inspectPage(currentHtml ?? '');
   const after = inspectPage(html ?? '');
   const converted = before.kind === 'yjs' || room?.pageTransition?.format === 'yjs';
@@ -50,7 +52,10 @@ export function checkPageWriteAdmission({ currentHtml, html, header = null, ifMa
     checkPageConversion({ header, currentHtml, html, ifMatch, room });
     return 'conversion';
   }
-  if (converted) return 'ordinary';
+  if (converted) {
+    checkOrdinaryLineage({ currentHtml, html, room });
+    return 'ordinary';
+  }
   if (after.kind !== 'yjs') {
     if (after.kind === 'invalid' && claimsYPage(html ?? '') && !claimsYPage(currentHtml ?? '')) refuse('invalid-capture');
     return 'ordinary';
@@ -59,5 +64,6 @@ export function checkPageWriteAdmission({ currentHtml, html, header = null, ifMa
   if (before.kind !== 'none' || typeof currentHtml !== 'string') refuse('invalid-source');
   checkInitialRoom(room);
   checkInitialCondition(ifMatch, currentHtml);
+  checkInitialLineage({ currentHtml, html, pageWrite, createDocument });
   return 'initial';
 }