@penpair/core 0.2.0 → 0.3.1

package/dist/journal.js

@@ -7,41 +7,71 @@ import { version } from "./version.js";
 import { runSnippet, snippet } from "./snippet.js";
 export async function readJournalTarget(client) {
     const result = await runSnippet(client, snippet("journal-target", "return { ok: true, fileId: penpot.currentFile.id, revision: penpot.currentFile.revn };", {}, "read"));
-    if (result.ok !== true || typeof result.fileId !== "string" || !result.fileId || !Number.isInteger(result.revision))
+    if (result.ok !== true ||
+        typeof result.fileId !== "string" ||
+        !result.fileId ||
+        !Number.isInteger(result.revision)) {
         throw new Error("Journal target identity/revision was not observed");
-    return { fileId: result.fileId, revision: Number(result.revision) };
+    }
+    return {
+        fileId: result.fileId,
+        revision: Number(result.revision),
+    };
 }
 /** Stable JSON hashing; observation comparisons may explicitly ignore transport execution metadata. */
 export function observationHash(value, ignoreExecution = false) {
     const canonical = (entry) => {
-        if (Array.isArray(entry))
+        if (Array.isArray(entry)) {
             return entry.map(canonical);
-        if (typeof entry !== "object" || entry === null)
+        }
+        if (typeof entry !== "object" || entry === null) {
             return entry;
-        return Object.fromEntries(Object.entries(entry).filter(([key]) => !ignoreExecution || key !== "execution").sort(([a], [b]) => a.localeCompare(b)).map(([key, child]) => [key, canonical(child)]));
+        }
+        return Object.fromEntries(Object.entries(entry)
+            .filter(([key]) => !ignoreExecution || key !== "execution")
+            .sort(([a], [b]) => a.localeCompare(b))
+            .map(([key, child]) => [
+            key,
+            canonical(child),
+        ]));
     };
-    return createHash("sha256").update(JSON.stringify(canonical(value)) ?? "null").digest("hex");
+    return createHash("sha256")
+        .update(JSON.stringify(canonical(value)) ?? "null")
+        .digest("hex");
 }
 function validateRunId(runId) {
-    if (!/^[a-zA-Z0-9-]{1,100}$/.test(runId))
+    if (!/^[a-zA-Z0-9-]{1,100}$/.test(runId)) {
         throw new Error("Run ID must contain only letters, digits and hyphens (at most 100)");
+    }
 }
 async function folder(root, create) {
-    if (create)
-        await ensureGitignoreEntry(root, ".penpair", { directory: true, comment: "penpair: private local operations and recovery evidence" });
+    if (create) {
+        await ensureGitignoreEntry(root, ".penpair", {
+            directory: true,
+            comment: "penpair: private local operations and recovery evidence",
+        });
+    }
     let current = root;
-    for (const segment of [".penpair", "runs"]) {
+    for (const segment of [
+        ".penpair",
+        "runs",
+    ]) {
         current = path.join(current, segment);
         try {
             const info = await lstat(current);
-            if (!info.isDirectory() || info.isSymbolicLink())
+            if (!info.isDirectory() || info.isSymbolicLink()) {
                 throw new Error("Operation journal directories must be real directories inside this project");
+            }
         }
         catch (error) {
-            if (error.code !== "ENOENT")
+            if (error.code !== "ENOENT") {
                 throw error;
-            if (create)
-                await mkdir(current, { mode: 0o700 });
+            }
+            if (create) {
+                await mkdir(current, {
+                    mode: 0o700,
+                });
+            }
         }
     }
     return current;
@@ -50,11 +80,18 @@ export async function readJournal(root, runId) {
     validateRunId(runId);
     const file = path.join(await folder(root, false), `${runId}.json`);
     const info = await lstat(file);
-    if (!info.isFile() || info.isSymbolicLink())
+    if (!info.isFile() || info.isSymbolicLink()) {
         throw new Error("Operation journal must be a regular local file");
+    }
     const record = JSON.parse(await readFile(file, "utf8"));
-    if (record.schemaVersion !== 1 || record.runId !== runId || typeof record.operation !== "string" || !Array.isArray(record.steps) || !record.target || typeof record.target.fileId !== "string")
+    if (record.schemaVersion !== 1 ||
+        record.runId !== runId ||
+        typeof record.operation !== "string" ||
+        !Array.isArray(record.steps) ||
+        !record.target ||
+        typeof record.target.fileId !== "string") {
         throw new Error("Operation journal is invalid or uses an unsupported schema");
+    }
     return record;
 }
 export async function listJournals(root) {
@@ -63,12 +100,23 @@ export async function listJournals(root) {
         files = await readdir(await folder(root, false));
     }
     catch (error) {
-        if (error.code === "ENOENT")
+        if (error.code === "ENOENT") {
             return [];
+        }
         throw error;
     }
-    const records = await Promise.all(files.filter((name) => /^[a-zA-Z0-9-]+\.json$/.test(name)).map((name) => readJournal(root, name.slice(0, -5))));
-    return records.map(({ runId, operation, state, target, updatedAt }) => ({ runId, operation, state, target, updatedAt })).sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+    const records = await Promise.all(files
+        .filter((name) => /^[a-zA-Z0-9-]+\.json$/.test(name))
+        .map((name) => readJournal(root, name.slice(0, -5))));
+    return records
+        .map(({ runId, operation, state, target, updatedAt }) => ({
+        runId,
+        operation,
+        state,
+        target,
+        updatedAt,
+    }))
+        .sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
 }
 export class JournalRunError extends Error {
     runId;
@@ -81,86 +129,183 @@ export class JournalRunError extends Error {
 }
 /** Each started phase is persisted before its write. Resume must inspect and reconcile actual state, never replay blindly. */
 export async function runJournaledSteps(steps, options) {
-    if (options.requireCheckpoint && !options.checkpoint)
+    if (options.requireCheckpoint && !options.checkpoint) {
         throw new Error("A required checkpoint needs a checkpoint provider");
+    }
     const runId = options.runId ?? randomUUID();
     validateRunId(runId);
     const redact = (text) => redactEndpoint(options.redact?.(text) ?? text);
     const directory = await folder(options.root, true);
     const destination = path.join(directory, `${runId}.json`);
     const target = await options.target();
-    if (!target || typeof target.fileId !== "string" || !target.fileId)
+    if (!target || typeof target.fileId !== "string" || !target.fileId) {
         throw new Error("Operation journal requires an observed file ID");
-    const inputHash = observationHash({ input: options.input, requireCheckpoint: options.requireCheckpoint === true, checkpointRequested: Boolean(options.checkpoint) });
-    const planHash = observationHash({ steps: steps.map(({ key, signature }) => ({ key, signature })), finalVerifier: options.finalVerify?.toString() });
-    if (new Set(steps.map((step) => step.key)).size !== steps.length)
+    }
+    const inputHash = observationHash({
+        input: options.input,
+        requireCheckpoint: options.requireCheckpoint === true,
+        checkpointRequested: Boolean(options.checkpoint),
+    });
+    const planHash = observationHash({
+        steps: steps.map(({ key, signature }) => ({
+            key,
+            signature,
+        })),
+        finalVerifier: options.finalVerify?.toString(),
+    });
+    if (new Set(steps.map((step) => step.key)).size !== steps.length) {
         throw new Error("Journal step keys must be unique");
+    }
     let record;
     if (options.resume) {
-        if (!options.runId)
+        if (!options.runId) {
             throw new Error("Resume requires the original run ID");
+        }
         record = await readJournal(options.root, runId);
-        if (record.redacted)
+        if (record.redacted) {
             throw new Error("This journal required redaction and cannot be automatically resumed; inspect and make a fresh plan");
-        if (record.engineVersion !== version || record.operation !== options.operation || record.inputHash !== inputHash || record.planHash !== planHash || record.target.fileId !== target.fileId || record.steps.length !== steps.length)
+        }
+        if (record.engineVersion !== version ||
+            record.operation !== options.operation ||
+            record.inputHash !== inputHash ||
+            record.planHash !== planHash ||
+            record.target.fileId !== target.fileId ||
+            record.steps.length !== steps.length) {
             throw new Error("Resume target, inputs, step implementation or engine version changed; no write was replayed");
+        }
     }
     else {
         const before = [];
-        for (const step of steps)
+        for (const step of steps) {
             before.push(step.initial === undefined ? await step.inspect() : step.initial);
+        }
         const observed = await options.target();
-        if (observed.fileId !== target.fileId || (target.revision !== undefined && observed.revision !== target.revision))
+        if (observed.fileId !== target.fileId ||
+            (target.revision !== undefined && observed.revision !== target.revision)) {
             throw new Error("File changed while planning; inspect again before starting a run");
+        }
         const now = new Date().toISOString();
-        record = { schemaVersion: 1, engineVersion: version, runId, operation: options.operation, inputHash, planHash, payload: options.payload, target, state: "planned", createdAt: now, updatedAt: now, redacted: false, steps: steps.map((step, index) => ({ key: step.key, label: step.label, state: "pending", before: before[index] })) };
+        record = {
+            schemaVersion: 1,
+            engineVersion: version,
+            runId,
+            operation: options.operation,
+            inputHash,
+            planHash,
+            payload: options.payload,
+            target,
+            state: "planned",
+            createdAt: now,
+            updatedAt: now,
+            redacted: false,
+            steps: steps.map((step, index) => ({
+                key: step.key,
+                label: step.label,
+                state: "pending",
+                before: before[index],
+            })),
+        };
     }
     const persist = async (create = false) => {
         record.updatedAt = new Date().toISOString();
         const sanitize = (value) => {
-            if (typeof value === "string")
+            if (typeof value === "string") {
                 return redact(value);
-            if (Array.isArray(value))
+            }
+            if (Array.isArray(value)) {
                 return value.map(sanitize);
-            if (value && typeof value === "object")
-                return Object.fromEntries(Object.entries(value).map(([key, entry]) => [redact(key), sanitize(entry)]));
+            }
+            if (value && typeof value === "object") {
+                return Object.fromEntries(Object.entries(value).map(([key, entry]) => [
+                    redact(key),
+                    sanitize(entry),
+                ]));
+            }
             return value;
         };
         const serialize = () => JSON.stringify(sanitize(record), null, 2);
-        if (serialize() !== JSON.stringify(record, null, 2))
+        if (serialize() !== JSON.stringify(record, null, 2)) {
             record.redacted = true;
+        }
         const temporary = path.join(directory, `.${runId}-${randomUUID()}.tmp`);
-        await writeFile(temporary, `${serialize()}\n`, { flag: "wx", mode: 0o600 });
+        await writeFile(temporary, `${serialize()}\n`, {
+            flag: "wx",
+            mode: 0o600,
+        });
         try {
-            if (create)
+            if (create) {
                 await link(temporary, destination);
-            else
+            }
+            else {
                 await rename(temporary, destination);
+            }
         }
         finally {
-            await unlink(temporary).catch((error) => { if (error.code !== "ENOENT")
-                throw error; });
+            await unlink(temporary).catch((error) => {
+                if (error.code !== "ENOENT") {
+                    throw error;
+                }
+            });
         }
     };
-    if (!options.resume)
+    if (!options.resume) {
         await persist(true);
+    }
     options.onStep?.(`operation run ${runId}`);
+    const traceStarted = Date.now();
+    const trace = (event, step, target) => {
+        if (!options.trace && !options.onTrace) {
+            return;
+        }
+        const entry = {
+            event,
+            at: new Date().toISOString(),
+            elapsedMs: Date.now() - traceStarted,
+            ...(step === undefined
+                ? {}
+                : {
+                    step,
+                }),
+            ...(target
+                ? {
+                    target: {
+                        fileId: redact(target.fileId),
+                        revision: target.revision,
+                    },
+                }
+                : {}),
+        };
+        if (options.trace) {
+            record.trace ??= [];
+            if (record.trace.length < 10000) {
+                record.trace.push(entry);
+            }
+        }
+        options.onTrace?.(structuredClone(entry));
+    };
     const assertTarget = async () => {
         const actual = await options.target();
-        if (actual.fileId !== record.target.fileId)
+        if (actual.fileId !== record.target.fileId) {
             throw new Error("The operation target file changed");
+        }
+        trace("revision-observed", undefined, actual);
         return actual;
     };
     let lease;
     try {
+        trace("lease-acquire-start", undefined, target);
         lease = await options.coordinate?.(runId, target);
-        if (options.checkpoint && record.steps.every((step) => step.state === "pending") && record.checkpoint === undefined) {
+        trace("lease-acquired", undefined, options.trace || options.onTrace ? await assertTarget() : undefined);
+        if (options.checkpoint &&
+            record.steps.every((step) => step.state === "pending") &&
+            record.checkpoint === undefined) {
             record.state = "running";
             await persist();
             await assertTarget();
             const checkpoint = await options.checkpoint(runId);
-            if (checkpoint.supported !== false && checkpoint.report?.verified !== true)
+            if (checkpoint.supported !== false && checkpoint.report?.verified !== true) {
                 throw new Error("Checkpoint did not provide verified recovery evidence");
+            }
             if (!checkpoint.supported && options.requireCheckpoint) {
                 record.state = "failed";
                 throw new Error("Required checkpoint API is unavailable; no operation step was applied");
@@ -172,8 +317,11 @@ export async function runJournaledSteps(steps, options) {
             const step = steps[index];
             const saved = record.steps[index];
             await lease?.check();
+            trace("lease-check", index);
             const beforeInspection = await assertTarget();
+            trace("inspection-start", index, beforeInspection);
             const current = await step.inspect();
+            trace("inspection-end", index);
             const afterInspection = await assertTarget();
             if (beforeInspection.revision !== afterInspection.revision) {
                 record.state = "conflict";
@@ -234,7 +382,7 @@ export async function runJournaledSteps(steps, options) {
                 throw error;
             }
         }
-        if (options.finalVerify && !await options.finalVerify()) {
+        if (options.finalVerify && !(await options.finalVerify())) {
             record.state = "failed";
             throw new Error("Final operation verification failed");
         }
@@ -245,16 +393,31 @@ export async function runJournaledSteps(steps, options) {
     }
     catch (error) {
         record.error = redact(error instanceof Error ? error.message : String(error));
-        if (record.state === "planned" || record.state === "running")
+        if (record.state === "planned" || record.state === "running") {
             record.state = "uncertain";
+        }
         try {
             await persist();
         }
-        catch { /* The pre-write started marker remains the recovery authority when a later local save fails. */ }
+        catch {
+            /* The pre-write started marker remains the recovery authority when a later local save fails. */
+        }
         throw new JournalRunError(runId, record.state, redact(error instanceof Error ? error.message : String(error)));
     }
     finally {
-        if (lease)
-            await lease.release().catch((error) => options.onStep?.(`Writer marker release needs inspection: ${redact(error instanceof Error ? error.message : String(error))}`));
+        if (lease) {
+            trace("lease-release-start");
+            try {
+                await lease.release();
+                trace("lease-released");
+            }
+            catch (error) {
+                trace("lease-release-failed");
+                options.onStep?.(`Writer marker release needs inspection: ${redact(error instanceof Error ? error.message : String(error))}`);
+            }
+            if (options.trace) {
+                await persist().catch(() => undefined);
+            }
+        }
     }
 }

package/dist/kit-smoke.js

@@ -16,8 +16,9 @@ const state=()=>{
  const result={fileId:f.id,pageId:p.id,structure,tokens,themes};if(JSON.stringify(result).length>30000)throw new Error("Kit probe needs a smaller scratch page/token context");return result;
 };`;
 export const kitSmokeOperation = {
-    name: "kit-smoke", page: () => undefined,
-    inspect: params => snippet("kit-smoke-inspect", `${snapshotBody}
+    name: "kit-smoke",
+    page: () => undefined,
+    inspect: (params) => snippet("kit-smoke-inspect", `${snapshotBody}
 const current=state(),effective=new Map();for(const set of penpot.library.local.tokens.sets)if(set.active)for(const token of set.tokens)effective.set(token.name,token);
 const pick=type=>{const names=[...effective.values()].filter(token=>token.type===type).map(token=>token.name).sort();if(!names.length)throw new Error("Kit probe needs an active "+type+" token on its scratch file");return names[0];};
 if(penpot.currentPage.root.children.some(shape=>shape.name===CFG.tag))throw new Error("A prior kit-probe root needs inspection before another run");
@@ -38,46 +39,107 @@ try{
  result={ok:true,built:true,actual,geometry:{width:card.width,height:card.height},previewBase64:btoa(binary),previewLength:second.length,capture:{fileId:penpot.currentFile.id,pageId:penpot.currentPage.id,frameId:root.id,revision:penpot.currentFile.revn,penpotApiVersion:typeof penpot.version==="string"?penpot.version:null},layout:settled.layout};
 }catch(error){result.error=String(error&&error.message||error);}
 finally{if(root)try{root.remove();}catch(error){result.cleanupError=String(error&&error.message||error);}}
-return result;`, { ...params, expected: inspected?.state ?? null, selected: inspected?.selected ?? null }, "write"),
+return result;`, {
+        ...params,
+        expected: inspected?.state ?? null,
+        selected: inspected?.selected ?? null,
+    }, "write"),
     readback: () => snippet("kit-smoke-readback", `${snapshotBody}\nreturn {ok:true,readOnly:true,state:state()};`, {}, "read"),
     verify({ inspect, apply, readback }) {
         const selected = inspect.selected;
         const problems = [];
-        if (!selected || apply.built !== true || apply.error || apply.cleanupError)
+        if (!selected || apply.built !== true || apply.error || apply.cleanupError) {
             problems.push(`Kit example failed: ${apply.error ?? apply.cleanupError ?? "no observed build"}`);
-        if (!selected || observationHash(apply.actual) !== observationHash({ text: "Hello, card", typography: selected.typo, color: selected.color, space: selected.space, radius: selected.radius }))
+        }
+        if (!selected ||
+            observationHash(apply.actual) !==
+                observationHash({
+                    text: "Hello, card",
+                    typography: selected.typo,
+                    color: selected.color,
+                    space: selected.space,
+                    radius: selected.radius,
+                })) {
             problems.push("Kit example lacks matching independent text/binding observations");
+        }
         const geometry = apply.geometry;
-        if (!geometry || typeof geometry.width !== "number" || !Number.isFinite(geometry.width) || geometry.width <= 0 || typeof geometry.height !== "number" || !Number.isFinite(geometry.height) || geometry.height <= 0)
+        if (!geometry ||
+            typeof geometry.width !== "number" ||
+            !Number.isFinite(geometry.width) ||
+            geometry.width <= 0 ||
+            typeof geometry.height !== "number" ||
+            !Number.isFinite(geometry.height) ||
+            geometry.height <= 0) {
             problems.push("Kit example has no finite positive geometry");
-        if (!inspect.state || !readback.state || observationHash(inspect.state) !== observationHash(readback.state))
+        }
+        if (!inspect.state ||
+            !readback.state ||
+            observationHash(inspect.state) !== observationHash(readback.state)) {
             problems.push("Kit cleanup did not independently preserve the original page and token selection");
-        if (typeof apply.previewBase64 !== "string" || !Number.isInteger(apply.previewLength) || Number(apply.previewLength) < 1)
+        }
+        if (typeof apply.previewBase64 !== "string" ||
+            !Number.isInteger(apply.previewLength) ||
+            Number(apply.previewLength) < 1) {
             problems.push("Kit example has no stable preview evidence");
+        }
         return problems;
     },
 };
 /** Opt-in scratch operation; uses existing active typed tokens and removes only its directly owned temporary root. */
 export async function runKitSmoke(client, root, options = {}) {
     const runId = options.journal?.runId ?? randomUUID();
-    const report = await runOperation(client, kitSmokeOperation, { tag: `_penpair-kit-${runId}` }, { ...options, journal: options.apply ? { ...options.journal, root, runId } : undefined });
+    const report = await runOperation(client, kitSmokeOperation, {
+        tag: `_penpair-kit-${runId}`,
+    }, {
+        ...options,
+        journal: options.apply
+            ? {
+                ...options.journal,
+                root,
+                runId,
+            }
+            : undefined,
+    });
     const encoded = report.apply?.previewBase64;
-    if (report.apply)
+    if (report.apply) {
         delete report.apply.previewBase64;
-    if (!report.verified || !report.apply)
+    }
+    if (!report.verified || !report.apply) {
         return report;
-    if (typeof encoded !== "string" || !/^[A-Za-z0-9+/]*={0,2}$/.test(encoded))
+    }
+    if (typeof encoded !== "string" || !/^[A-Za-z0-9+/]*={0,2}$/.test(encoded)) {
         throw new Error("Kit preview encoding is invalid");
+    }
     const bytes = Buffer.from(encoded, "base64");
-    if (bytes.length !== report.apply.previewLength || bytes.length > 2097152)
+    if (bytes.length !== report.apply.previewLength || bytes.length > 2097152) {
         throw new Error("Kit preview byte evidence is invalid");
+    }
     const destination = await resolveProjectOutput(root, `.penpair/probes/kit-${runId}.png`);
-    await mkdir(path.dirname(destination), { recursive: true, mode: 0o700 });
-    const existing = await readFile(destination).catch((error) => { if (error.code !== "ENOENT")
-        throw error; return undefined; });
-    if (existing && !existing.equals(bytes))
+    await mkdir(path.dirname(destination), {
+        recursive: true,
+        mode: 0o700,
+    });
+    const existing = await readFile(destination).catch((error) => {
+        if (error.code !== "ENOENT") {
+            throw error;
+        }
+        return undefined;
+    });
+    if (existing && !existing.equals(bytes)) {
         throw new Error("Existing kit preview differs; previous evidence was preserved");
-    if (!existing)
-        await atomicWriteFile(destination, bytes, { mode: 0o600 });
-    return { ...report, preview: { path: destination, bytes: bytes.length, sha256: createHash("sha256").update(bytes).digest("hex"), visualApproval: false } };
+    }
+    if (!existing) {
+        await atomicWriteFile(destination, bytes, {
+            mode: 0o600,
+        });
+    }
+    return {
+        ...report,
+        preview: {
+            path: destination,
+            bytes: bytes.length,
+            sha256: createHash("sha256").update(bytes).digest("hex"),
+            visualApproval: false,
+        },
+    };
 }

package/dist/kit-source.js

@@ -1,3 +1,4 @@
+import { layoutPolicySource } from "./layout-policy.js";
 /** Plain plugin-sandbox JavaScript. Inclusion defines helpers without touching the document. */
 export const coreKitSource = String.raw `// penpair: read
 const pp = (() => {
@@ -218,45 +219,14 @@ const pp = (() => {
     const fillV = shape => { if (!shape.layoutChild)
         throw new Error("Layout child unavailable"); shape.layoutChild.verticalSizing = "fill"; return shape; };
     const wait = milliseconds => new Promise(resolve => setTimeout(resolve, milliseconds));
+    ${layoutPolicySource}
     const settle = async (root = penpot.currentPage.root, options = {}) => {
-        const timeout = options.timeoutMs === undefined ? 10000 : options.timeoutMs, interval = options.intervalMs === undefined ? 100 : options.intervalMs, maxNodes = options.maxNodes === undefined ? 10000 : options.maxNodes;
-        if (!Number.isInteger(timeout) || timeout < 1 || timeout > 30000 || !Number.isInteger(interval) || interval < 1 || interval > 1000 || !Number.isInteger(maxNodes) || maxNodes < 1 || maxNodes > 10000)
-            throw new Error("Invalid settling budgets");
-        const started = Date.now(), sample = () => { const rows = [], stack = [root], seen = new Set(); while (stack.length) {
-            if (rows.length >= maxNodes)
-                throw new Error("Settling node budget exceeded");
-            const shape = stack.pop();
-            if (!shape || !shape.id || seen.has(shape.id) || ![shape.x, shape.y, shape.width, shape.height].every(Number.isFinite))
-                throw new Error("Malformed settling geometry");
-            seen.add(shape.id);
-            rows.push([shape.id, shape.x, shape.y, shape.width, shape.height]);
-            for (const child of shape.children || [])
-                stack.push(child);
-        } return JSON.stringify(rows); };
-        try {
-            const target = root && typeof root.waitForLayoutUpdate === "function" ? root : penpot;
-            if (typeof target.waitForLayoutUpdate === "function") {
-                await target.waitForLayoutUpdate(timeout);
-                sample();
-                if (Date.now() - started >= timeout)
-                    return { stable: false, method: "native", samples: 1, reason: "Native layout exceeded deadline" };
-                return { stable: true, method: "native", samples: 1 };
-            }
-            let previous = sample();
-            for (let samples = 2; samples <= 1000 && Date.now() - started < timeout; samples++) {
-                await wait(Math.min(interval, Math.max(1, timeout - (Date.now() - started))));
-                const current = sample();
-                if (Date.now() - started >= timeout)
-                    break;
-                if (current === previous)
-                    return { stable: true, method: "geometry", samples };
-                previous = current;
-            }
-            return { stable: false, method: "geometry", reason: "Layout did not settle within budget" };
-        }
-        catch (error) {
-            return { stable: false, method: "unavailable", reason: String(error && error.message || error) };
-        }
+        const fileId = penpot.currentFile.id, pageId = penpot.currentPage.id;
+        try { return await settleLayout(async nativeMs => {
+            if (penpot.currentFile.id !== fileId || penpot.currentPage.id !== pageId) throw new Error("Layout target changed between samples");
+            return observeLayout(penpot, root, { nativeMs, maxNodes: options.maxNodes });
+        }, { timeoutMs: options.timeoutMs === undefined ? 10000 : options.timeoutMs, intervalMs: options.intervalMs === undefined ? 100 : options.intervalMs, strategy: options.strategy === undefined ? "auto" : options.strategy, sleep: wait }); }
+        catch (error) { return { stable: false, method: "unavailable", samples: 0, reason: String(error && error.message || error) }; }
     };
     const flush = async (options = {}) => {
         if (flushing)
@@ -269,7 +239,7 @@ const pp = (() => {
         try {
             if (queuedContext !== null && context() !== queuedContext)
                 throw new Error("Active token context changed before flush");
-            let layout = await settle(options.root || penpot.currentPage.root, { timeoutMs: remaining() });
+            let layout = await settle(options.root || penpot.currentPage.root, { timeoutMs: remaining(), strategy: options.strategy });
             if (!layout.stable)
                 throw new Error(layout.reason || "Layout did not settle");
             if (queuedContext !== null && context() !== queuedContext)
@@ -288,7 +258,7 @@ const pp = (() => {
                 bindings.shift();
                 applied++;
             }
-            layout = await settle(options.root || penpot.currentPage.root, { timeoutMs: remaining() });
+            layout = await settle(options.root || penpot.currentPage.root, { timeoutMs: remaining(), strategy: options.strategy });
             if (!layout.stable)
                 throw new Error(layout.reason || "Layout did not settle");
             queuedContext = null;