e10-ebuilder-prototype 0.5.0

package/dist/capture.js

@@ -0,0 +1,440 @@
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { chromeExecutable, cleanupOwnedDirectory, terminateProcessTree, processAlive, renameWithRetry, environmentValue, } from './runtime-support.mjs';
+import { chromium } from 'playwright-core';
+import { bounded, CaptureError, digest, errorInfo, sleep } from './common.js';
+import { filenames } from './store.js';
+import { Monitor, ready, sample, lazyScroll } from './readiness.js';
+import { expandScrollers } from './dom.mjs';
+export async function launchChrome() {
+    const env = { ...process.env };
+    if (process.platform === 'win32') {
+        const local = environmentValue(env, 'LOCALAPPDATA') || path.join(os.homedir(), 'AppData', 'Local');
+        if (!path.isAbsolute(local))
+            throw new CaptureError('BROWSER_PROFILE_INVALID', 'LOCALAPPDATA 必须为绝对路径');
+        await fs.mkdir(local, { recursive: true });
+        for (const key of Object.keys(env))
+            if (key.toLowerCase() === 'localappdata')
+                delete env[key];
+        env.LOCALAPPDATA = local;
+    }
+    const executablePath = chromeExecutable({ env });
+    const parent = await fs.realpath(os.tmpdir());
+    const directory = await fs.mkdtemp(path.join(parent, 'e10-capture-browser-'));
+    const artifactsDir = path.join(directory, 'artifacts');
+    await fs.mkdir(artifactsDir);
+    let context;
+    let pid;
+    const closeTimeout = process.platform === 'win32' ? 30000 : 15000;
+    let closed = false;
+    const close = async () => {
+        if (closed)
+            return;
+        closed = true;
+        let error;
+        try {
+            if (context)
+                await bounded(context.close(), closeTimeout, 'BROWSER_CLOSE_TIMEOUT');
+        }
+        catch (e) {
+            error = e;
+        }
+        try {
+            if (pid && processAlive(pid))
+                await terminateProcessTree(pid);
+        }
+        catch (e) {
+            error ??= e;
+        }
+        try {
+            await cleanupOwnedDirectory(directory, parent, 'e10-capture-browser-');
+        }
+        catch (e) {
+            error ??= e;
+        }
+        if (error)
+            throw error;
+    };
+    try {
+        // Own both directories: Playwright must not recursively delete an implicit
+        // temporary Chrome profile inside the WorkBuddy host process on Windows.
+        context = await chromium.launchPersistentContext(path.join(directory, 'profile'), {
+            executablePath,
+            artifactsDir,
+            env,
+            headless: true,
+            timeout: 30000,
+            handleSIGINT: false,
+            handleSIGTERM: false,
+            handleSIGHUP: false,
+        });
+        const browser = context.browser();
+        const cdp = await browser.newBrowserCDPSession();
+        try {
+            const info = await cdp.send('SystemInfo.getProcessInfo');
+            pid = info.processInfo.find((p) => p.type === 'browser')?.id;
+            if (!pid || !Number.isSafeInteger(pid))
+                throw new CaptureError('BROWSER_PID_MISSING', '无法确认受控 Chrome 进程');
+        }
+        finally {
+            await cdp.detach();
+        }
+        for (const page of context.pages())
+            await page.close();
+        return { browser, pid, version: browser.version(), directory, close };
+    }
+    catch (e) {
+        await close();
+        throw e;
+    }
+}
+async function oneAttempt(context, store, item, state, auth, attempt, requireEntrance) {
+    let page, monitor, cancelled = false;
+    const operation = (async () => {
+        attempt.stage = 'create-page';
+        page = await context.newPage();
+        if (cancelled) {
+            await page.close();
+            throw new CaptureError('CANCELLED', '任务已取消');
+        }
+        page.setDefaultTimeout(15000);
+        monitor = new Monitor(page, new URL(auth.baseUrl).origin, {
+            id: item.id,
+            layoutType: item.type,
+        });
+        const navigationStarted = Date.now();
+        const initial = await bounded((async () => {
+            attempt.stage = 'navigate';
+            const navigation = new URL(item.url);
+            // Enter the platform's canonical EB route directly, avoiding its delayed full reload.
+            if (item.type && navigation.pathname === `/sp/ebdpage/view/${item.id}`)
+                navigation.pathname += `/page/${item.id}`;
+            await page.goto(navigation.href, {
+                waitUntil: 'domcontentloaded',
+                timeout: state.settings.timeoutMs,
+            });
+            if (new URL(page.url()).origin !== new URL(item.url).origin ||
+                /\/(login|passport)(\/|\?|$)/i.test(page.url()))
+                throw new CaptureError('E10_LOGIN_REQUIRED', '页面跳转登录或其它环境');
+            attempt.stage = 'initial-ready';
+            return ready(page, item.id, monitor, navigationStarted + state.settings.timeoutMs, state.settings.stableMs, requireEntrance);
+        })(), state.settings.timeoutMs, 'LOADING_TIMEOUT');
+        const loadingMs = Date.now() - navigationStarted;
+        const warningMap = new Map();
+        const retainWarnings = (sampled) => {
+            for (const w of sampled.evidence.warnings)
+                warningMap.set(`${w.code}:${w.message}`, w);
+            return sampled;
+        };
+        retainWarnings(initial);
+        const wait = async () => retainWarnings(await ready(page, item.id, monitor, Date.now() + state.settings.timeoutMs, state.settings.stableMs, requireEntrance));
+        attempt.stage = 'lazy-scroll';
+        // This iframe is the EB page itself. Ordinary embedded websites retain their viewport.
+        let embeddedPage;
+        if (monitor.pageConfig?.id === item.id && monitor.pageConfig.layoutType === 'ECODE_HTML') {
+            const element = await page.$('.weapp-de-sourcecode-render.sourcecode-html iframe');
+            try {
+                const frame = await element?.contentFrame();
+                if (!frame ||
+                    new URL(frame.url()).origin !== new URL(item.url).origin ||
+                    !new URL(frame.url()).pathname.startsWith('/sp/chtml/'))
+                    throw new CaptureError('PAGE_FRAME_UNAVAILABLE', 'EB 页面内容尚未进入可读取的预览框架');
+                await lazyScroll(frame, wait);
+                const inside = await expandScrollers(frame, undefined);
+                if (inside.residual)
+                    throw new CaptureError('SCROLL_REMAINS', '页面内容仍有未展开的内部滚动区');
+                embeddedPage = await frame.evaluate(() => ({
+                    width: Math.max(document.documentElement.scrollWidth, document.body.scrollWidth),
+                    height: Math.max(document.documentElement.scrollHeight, document.body.scrollHeight),
+                }));
+                if (embeddedPage.height > 50000 || embeddedPage.width * embeddedPage.height > 60000000)
+                    throw new CaptureError('IMAGE_TOO_LARGE', '页面内容超过截图尺寸上限');
+                await element.evaluate((e, size) => {
+                    const node = e;
+                    node.style.setProperty('height', `${size.height}px`, 'important');
+                    node.style.setProperty('width', `${size.width}px`, 'important');
+                    node.style.setProperty('max-height', 'none', 'important');
+                    node.style.setProperty('flex-shrink', '0', 'important');
+                    for (let p = node.parentElement; p; p = p.parentElement) {
+                        p.style.setProperty('height', 'auto', 'important');
+                        p.style.setProperty('max-height', 'none', 'important');
+                        p.style.setProperty('overflow', 'visible', 'important');
+                    }
+                }, embeddedPage);
+                await wait();
+            }
+            finally {
+                await element?.dispose();
+            }
+        }
+        const scrollers = await lazyScroll(page, wait);
+        attempt.stage = 'expand';
+        const expansion = await expandScrollers(page, undefined);
+        if (expansion.residual)
+            throw new CaptureError('SCROLL_REMAINS', '仍有内部滚动区未展开', expansion);
+        attempt.stage = 'final-ready';
+        const before = await wait();
+        const missing = initial.evidence.components.filter((c) => !before.evidence.components.some((v) => v.id === c.id));
+        if (missing.length)
+            throw new CaptureError('COMPONENT_DISAPPEARED', '滚动后组件缺失', { missing });
+        if (before.evidence.height > 50000 || before.evidence.height * before.evidence.width > 60000000)
+            throw new CaptureError('IMAGE_TOO_LARGE', '页面超过 50000px 高度或 6000 万像素上限', before.evidence);
+        attempt.stage = 'screenshot';
+        const epoch = monitor.epoch;
+        const png = await page.screenshot({
+            fullPage: true,
+            type: 'png',
+            scale: 'css',
+            timeout: 10000,
+            caret: 'initial',
+        });
+        attempt.stage = 'post-capture';
+        const after = retainWarnings(await sample(page, item.id, requireEntrance, monitor));
+        if (!after.ready || before.contentSignature !== after.contentSignature)
+            throw new CaptureError('CAPTURE_CHANGED', '截图期间内容、布局或网络状态发生变化', {
+                before: before.evidence,
+                after: after.evidence,
+                ready: after.ready,
+                contentChanged: before.contentSignature !== after.contentSignature,
+                layoutChanged: before.signature !== after.signature,
+                networkChanged: epoch !== monitor.epoch,
+            });
+        const width = png.readUInt32BE(16), height = png.readUInt32BE(20);
+        if (Math.min(Math.abs(width - before.evidence.width), Math.abs(width - after.evidence.width)) >
+            4 ||
+            Math.min(Math.abs(height - before.evidence.height), Math.abs(height - after.evidence.height)) > 4)
+            throw new CaptureError('PNG_BOUNDS_MISMATCH', 'PNG 尺寸与完整页面不一致', {
+                width,
+                height,
+                expected: [before.evidence.width, before.evidence.height],
+            });
+        return {
+            png,
+            width,
+            height,
+            warnings: [...warningMap.values()],
+            evidence: {
+                loadingMs,
+                initial: initial.evidence,
+                final: after.evidence,
+                scrollers,
+                expansion,
+                embeddedPage,
+                requests: monitor.evidence(),
+            },
+        };
+    })();
+    let output, error;
+    try {
+        output = await bounded(operation, state.settings.timeoutMs + 130000, 'ATTEMPT_TIMEOUT');
+    }
+    catch (e) {
+        error = e;
+        attempt.evidence = monitor?.evidence();
+        if (page && !page.isClosed())
+            try {
+                const relative = `diagnostics/${filenames(state.pages || [item])
+                    .get(item.id)
+                    .replace(/\.png$/, '')}-attempt-${attempt.number}.png`;
+                await fs.mkdir(store.artifact('diagnostics'), { recursive: true });
+                await bounded(page.screenshot({ path: store.artifact(relative), timeout: 3000 }), 4000, 'DIAGNOSTIC_TIMEOUT');
+                attempt.diagnostic = relative;
+            }
+            catch {
+                /* diagnostic is best effort, original error remains */
+            }
+    }
+    finally {
+        cancelled = true;
+        if (page)
+            try {
+                await bounded(page.close(), 8000, 'PAGE_CLOSE_TIMEOUT');
+            }
+            catch (e) {
+                attempt.cleanupError = errorInfo(e).code;
+                error ??= e;
+            }
+    }
+    if (error)
+        throw error;
+    return output;
+}
+export async function capture(store, state, auth, options = {}) {
+    if (!state.pages)
+        throw new CaptureError('DISCOVERY_REQUIRED', '先执行 discover');
+    store.bind(state, auth);
+    const pending = [];
+    for (const item of state.pages) {
+        const r = await store.result(item.id);
+        if (await store.verified(r))
+            continue;
+        if (r?.status === 'failed' && !options.retryFailed)
+            continue;
+        pending.push(item);
+    }
+    if (!pending.length)
+        return;
+    delete state.archive;
+    await store.save(state);
+    const chrome = await launchChrome();
+    const contexts = new Map();
+    const names = filenames(state.pages);
+    let cursor = 0, active = 0, peak = 0, closed = 0, stopped = false, fatal;
+    const signal = () => {
+        stopped = true;
+        void chrome.browser.close().catch(() => { });
+    };
+    process.once('SIGINT', signal);
+    process.once('SIGTERM', signal);
+    const started = Date.now();
+    options.progress?.({
+        event: 'browser-start',
+        pid: chrome.pid,
+        version: chrome.version,
+        concurrency: state.settings.concurrency,
+        pages: pending.length,
+    });
+    async function worker() {
+        while (!stopped && cursor < pending.length) {
+            const item = pending[cursor++];
+            active++;
+            peak = Math.max(peak, active);
+            try {
+                const previous = await store.result(item.id);
+                const result = previous || {
+                    id: item.id,
+                    name: item.name,
+                    url: item.url,
+                    status: 'running',
+                    history: [],
+                };
+                if (result.history.at(-1)?.status === 'running') {
+                    const last = result.history.at(-1);
+                    last.status = 'failed';
+                    last.error = { code: 'INTERRUPTED', message: '上次进程中断' };
+                    last.finishedAt = new Date().toISOString();
+                }
+                delete result.file;
+                delete result.sha256;
+                delete result.bytes;
+                delete result.warnings;
+                result.status = 'running';
+                for (let retry = 0; retry <= state.settings.retries && !stopped; retry++) {
+                    const attempt = {
+                        number: result.history.length + 1,
+                        status: 'running',
+                        stage: 'start',
+                        startedAt: new Date().toISOString(),
+                    };
+                    result.history.push(attempt);
+                    await store.saveResult(result);
+                    try {
+                        const output = await oneAttempt(contexts.get(item.terminal), store, item, state, auth, attempt, options.requireEntrance !== false);
+                        attempt.evidence = output.evidence;
+                        const file = names.get(item.id);
+                        await fs.mkdir(store.artifacts, { recursive: true });
+                        const temp = store.artifact(`${file}.${process.pid}.tmp`);
+                        await fs.writeFile(temp, output.png, { mode: 0o600 });
+                        await renameWithRetry(temp, store.artifact(file));
+                        Object.assign(result, {
+                            status: 'succeeded',
+                            warnings: output.warnings,
+                            file,
+                            sha256: digest(output.png),
+                            bytes: output.png.length,
+                            width: output.width,
+                            height: output.height,
+                        });
+                        attempt.status = 'succeeded';
+                    }
+                    catch (e) {
+                        attempt.status = 'failed';
+                        attempt.error = errorInfo(e, auth.eteamsId);
+                        result.status = 'failed';
+                        if (attempt.cleanupError || attempt.error.code === 'E10_LOGIN_REQUIRED') {
+                            stopped = true;
+                            fatal = e;
+                        }
+                    }
+                    finally {
+                        attempt.finishedAt = new Date().toISOString();
+                        attempt.elapsedMs = Date.parse(attempt.finishedAt) - Date.parse(attempt.startedAt);
+                        await store.saveResult(result);
+                    }
+                    options.progress?.({
+                        event: 'page-attempt',
+                        id: item.id,
+                        name: item.name,
+                        attempt: attempt.number,
+                        status: attempt.status,
+                        stage: attempt.stage,
+                        elapsedMs: attempt.elapsedMs,
+                        error: attempt.error,
+                    });
+                    if (attempt.status === 'succeeded' ||
+                        stopped ||
+                        /TIMEOUT/.test(attempt.error?.code || '') ||
+                        /Timeout .*exceeded/.test(attempt.error?.message || ''))
+                        break;
+                    await sleep(300 * (retry + 1));
+                }
+            }
+            catch (e) {
+                fatal = e;
+                stopped = true;
+            }
+            finally {
+                active--;
+                closed++;
+                options.progress?.({
+                    event: 'page-released',
+                    id: item.id,
+                    active,
+                    completed: closed,
+                    total: pending.length,
+                });
+            }
+        }
+    }
+    try {
+        for (const terminal of new Set(pending.map((p) => p.terminal))) {
+            const context = await bounded(chrome.browser.newContext(terminal === 'MOBILE'
+                ? {
+                    viewport: { width: 390, height: 844 },
+                    deviceScaleFactor: 1,
+                    isMobile: true,
+                    hasTouch: true,
+                    userAgent: 'Mozilla/5.0 (Linux; Android 13) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/153.0.0.0 Mobile Safari/537.36',
+                }
+                : {
+                    viewport: { width: state.settings.width, height: state.settings.height },
+                    deviceScaleFactor: 1,
+                }), 15000, 'CONTEXT_CREATE_TIMEOUT');
+            contexts.set(terminal, context);
+            await context.addCookies([{ name: 'ETEAMSID', value: auth.eteamsId, url: auth.baseUrl }]);
+        }
+        await Promise.all(Array.from({ length: Math.min(state.settings.concurrency, pending.length) }, worker));
+    }
+    finally {
+        process.removeListener('SIGINT', signal);
+        process.removeListener('SIGTERM', signal);
+        try {
+            await Promise.all([...contexts.values()].map((c) => bounded(c.close(), 8000, 'CONTEXT_CLOSE_TIMEOUT')));
+        }
+        finally {
+            await chrome.close();
+        }
+        options.progress?.({
+            event: 'browser-closed',
+            pid: chrome.pid,
+            directory: chrome.directory,
+            peakConcurrency: peak,
+            elapsedMs: Date.now() - started,
+        });
+    }
+    if (fatal)
+        throw fatal;
+    if (stopped)
+        throw new CaptureError('INTERRUPTED', '批次已中断，可重新 run 恢复');
+}

package/dist/common.d.ts

@@ -0,0 +1,20 @@
+export declare const VERSION = "0.5.0";
+export declare class CaptureError extends Error {
+    code: string;
+    details?: unknown | undefined;
+    constructor(code: string, message: string, details?: unknown | undefined);
+}
+export declare const sleep: (ms: number) => Promise<void>;
+export declare function digest(data: string | Uint8Array): string;
+export declare function fileDigest(filename: string): Promise<string>;
+export declare function mapLimit<T, R>(items: T[], limit: number, action: (item: T) => Promise<R>): Promise<R[]>;
+export declare function atomicJson(filename: string, value: unknown): Promise<void>;
+export declare function readJson<T>(filename: string): Promise<T>;
+export declare function bounded<T>(promise: Promise<T>, ms: number, code: string): Promise<T>;
+export declare function safeName(value: string): string;
+export declare function id(value: unknown, label?: string): string;
+export declare function errorInfo(error: unknown, secret?: string): {
+    details?: unknown;
+    code: string;
+    message: string;
+};

package/dist/common.js

@@ -0,0 +1,87 @@
+import fs from 'node:fs/promises';
+import { renameWithRetry } from './runtime-support.mjs';
+import { createReadStream } from 'node:fs';
+import path from 'node:path';
+import { createHash, randomUUID } from 'node:crypto';
+export const VERSION = '0.5.0';
+export class CaptureError extends Error {
+    code;
+    details;
+    constructor(code, message, details) {
+        super(message);
+        this.code = code;
+        this.details = details;
+        this.name = 'CaptureError';
+    }
+}
+export const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+export function digest(data) {
+    return createHash('sha256').update(data).digest('hex');
+}
+export async function fileDigest(filename) {
+    const hash = createHash('sha256');
+    for await (const chunk of createReadStream(filename))
+        hash.update(chunk);
+    return hash.digest('hex');
+}
+export async function mapLimit(items, limit, action) {
+    const out = new Array(items.length);
+    let cursor = 0;
+    await Promise.all(Array.from({ length: Math.min(limit, items.length) }, async () => {
+        while (cursor < items.length) {
+            const i = cursor++;
+            out[i] = await action(items[i]);
+        }
+    }));
+    return out;
+}
+export async function atomicJson(filename, value) {
+    await fs.mkdir(path.dirname(filename), { recursive: true });
+    const temp = `${filename}.${process.pid}.${randomUUID()}.tmp`;
+    try {
+        await fs.writeFile(temp, JSON.stringify(value, null, 2) + '\n', { flag: 'wx', mode: 0o600 });
+        await renameWithRetry(temp, filename);
+    }
+    finally {
+        await fs.rm(temp, { force: true });
+    }
+}
+export async function readJson(filename) {
+    return JSON.parse(await fs.readFile(filename, 'utf8'));
+}
+export async function bounded(promise, ms, code) {
+    let timer;
+    try {
+        return await Promise.race([
+            promise,
+            new Promise((_, reject) => {
+                timer = setTimeout(() => reject(new CaptureError(code, `超过 ${ms}ms 上限`)), ms);
+            }),
+        ]);
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+export function safeName(value) {
+    return (Array.from(value
+        .normalize('NFC')
+        .replace(/[\x00-\x1f<>:"/\\|?*]/g, '_')
+        .replace(/[.\s]+$/g, ''))
+        .slice(0, 65)
+        .join('') || 'page');
+}
+export function id(value, label = 'id') {
+    if (typeof value !== 'string' || !/^\d{1,30}$/.test(value))
+        throw new CaptureError('INVALID_ID', `${label} 必须是十进制字符串`);
+    return value;
+}
+export function errorInfo(error, secret = '') {
+    const e = error;
+    const clean = (v) => (secret ? v.replaceAll(secret, '[REDACTED]') : v);
+    return {
+        code: e.code || (e.name === 'TimeoutError' ? 'OPERATION_TIMEOUT' : 'UNEXPECTED_ERROR'),
+        message: clean(e.message || String(error)),
+        ...(e.details ? { details: JSON.parse(clean(JSON.stringify(e.details))) } : {}),
+    };
+}

package/dist/dom.d.mts

@@ -0,0 +1 @@
+export function expandScrollers(frame: any, scrollSelector: any): Promise<any>;

package/dist/dom.mjs

@@ -0,0 +1,58 @@
+// Browser-side DOM helpers extracted from the validated screenshot prototype.
+export async function expandScrollers(frame, scrollSelector) {
+    return frame.evaluate(({ scrollSelector }) => {
+        const root = document.scrollingElement || document.documentElement;
+        const explicit = new Set(scrollSelector ? document.querySelectorAll(scrollSelector) : []);
+        const modified = new Set();
+        const grow = (e, property, value) => e.style.setProperty(property, value, 'important');
+        for (let pass = 0; pass < 8; pass++) {
+            const regions = [...document.querySelectorAll('*')].filter((e) => {
+                if (e === root ||
+                    e.clientHeight < 60 ||
+                    e.clientWidth < 60 ||
+                    getComputedStyle(e).visibility === 'hidden')
+                    return false;
+                const style = getComputedStyle(e);
+                return (((explicit.has(e) || /(auto|scroll)/.test(style.overflowY)) &&
+                    e.scrollHeight > e.clientHeight + 3) ||
+                    (/(auto|scroll)/.test(style.overflowX) && e.scrollWidth > e.clientWidth + 3));
+            });
+            if (!regions.length)
+                break;
+            for (const e of regions.reverse()) {
+                const height = e.scrollHeight + Math.max(0, e.offsetHeight - e.clientHeight);
+                const width = e.scrollWidth + Math.max(0, e.offsetWidth - e.clientWidth);
+                if (e.scrollHeight > e.clientHeight + 3)
+                    grow(e, 'height', `${height}px`);
+                if (e.scrollWidth > e.clientWidth + 3)
+                    grow(e, 'width', `${width}px`);
+                for (const [key, value] of Object.entries({
+                    'max-height': 'none',
+                    'max-width': 'none',
+                    overflow: 'visible',
+                    'flex-shrink': '0',
+                    contain: 'none',
+                }))
+                    grow(e, key, value);
+                e.scrollTop = 0;
+                e.scrollLeft = 0;
+                modified.add(e);
+                for (let p = e.parentElement; p; p = p.parentElement) {
+                    grow(p, 'overflow', 'visible');
+                    grow(p, 'max-height', 'none');
+                    grow(p, 'height', 'auto');
+                    grow(p, 'contain', 'none');
+                    grow(p, 'flex-shrink', '0');
+                }
+            }
+        }
+        window.scrollTo(0, 0);
+        const residual = [...document.querySelectorAll('*')].filter((e) => e !== root &&
+            e.clientHeight > 60 &&
+            e.clientWidth > 60 &&
+            getComputedStyle(e).visibility !== 'hidden' &&
+            /(auto|scroll)/.test(getComputedStyle(e).overflowY) &&
+            e.scrollHeight > e.clientHeight + 3).length;
+        return { expanded: modified.size, residual };
+    }, { scrollSelector });
+}

package/dist/form-context.d.ts

@@ -0,0 +1,3 @@
+import type { Store } from './store.js';
+/** Generated source views are disposable; regenerate from the verified canonical input on resume. */
+export declare function formContext(store: Store, key: string): Promise<string>;

package/dist/form-context.js

@@ -0,0 +1,58 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { fileDigest } from './common.js';
+import { formInputPath } from './forms.js';
+import { navigationKey } from './menus.js';
+function* parts(value, location) {
+    if (JSON.stringify(value).length <= 18000) {
+        yield { location, value };
+        return;
+    }
+    if (Array.isArray(value)) {
+        for (const [i, item] of value.entries())
+            yield* parts(item, `${location}[${i}]`);
+    }
+    else if (value && typeof value === 'object') {
+        for (const [key, item] of Object.entries(value))
+            yield* parts(item, `${location}.${key}`);
+    }
+    else if (typeof value === 'string') {
+        for (let offset = 0; offset < value.length; offset += 6000)
+            yield {
+                location: `${location} (characters ${offset}:${Math.min(value.length, offset + 6000)})`,
+                value: value.slice(offset, offset + 6000),
+            };
+    }
+    else
+        yield { location, value };
+}
+/** Generated source views are disposable; regenerate from the verified canonical input on resume. */
+export async function formContext(store, key) {
+    const source = formInputPath(store, key), input = JSON.parse(await fs.readFile(source, 'utf8'));
+    const folder = path.join(store.meta, 'form-context', navigationKey(key), await fileDigest(source));
+    await fs.mkdir(folder, { recursive: true });
+    const index = [];
+    for (const [category, value] of Object.entries(input)) {
+        let i = 0;
+        for (const part of parts(value, category)) {
+            const filename = `${category.replace(/[^a-zA-Z0-9_-]/g, '_')}-${++i}.json`;
+            await fs.writeFile(path.join(folder, filename), JSON.stringify(part, null, 2), {
+                mode: 0o600,
+            });
+            index.push({ path: filename, location: part.location });
+        }
+    }
+    const indexPath = path.join(folder, 'index.json');
+    await fs.writeFile(indexPath, JSON.stringify({
+        source,
+        appId: input.appId,
+        objId: input.objId,
+        menu: input.page,
+        fieldCount: input.fields?.length,
+        customFieldCount: input.fields?.filter((f) => !f.system).length,
+        layoutSource: input.layout?.source,
+        warnings: input.warnings,
+        fragments: index,
+    }, null, 2), { mode: 0o600 });
+    return indexPath;
+}

package/dist/form-runtime.d.mts

@@ -0,0 +1,2 @@
+export function formRuntime(scope: any, objectIds?: any[]): string;
+export function attachFormRuntime(source: any, scope: any, objectIds?: any[]): any;