create-agdf 0.20.2 → 0.31.0

package/generated/plugins/agdf/runtime/create-agdf/runtime/core/lib/owner-placement.js

@@ -0,0 +1,50 @@
+import { constants, closeSync, fstatSync, lstatSync, openSync, realpathSync } from 'node:fs';
+import { basename, dirname, join, resolve } from 'node:path';
+
+// Internal fixed owner roles. The owner binds bytes, intent and producer; this
+// helper binds existing objects across mount-session device-number changes.
+const anchors = Object.freeze({ 'canonical-control': '.agdf-canonical-init.json', 'marketplace-publication': '.agdf-owned.json' });
+const inode = value => typeof value === 'bigint' && value > 0n ? String(value) : (() => { throw Error('owner_placement_unsupported'); })();
+function directory(path) {
+  const resolved = resolve(path), real = realpathSync(path);
+  // Preserve the platform's fixed system aliases used by existing CLI/installer
+  // temp paths. A linked target entry or any additional linked ancestor rejects.
+  if (real !== resolved && !(process.platform === 'darwin'
+    && real === resolved.replace(/^\/(var|tmp|etc)(?=\/|$)/u, '/private/$1'))) throw Error('owner_placement_unsafe');
+  const stat = lstatSync(path, { bigint: true });
+  if (!stat.isDirectory() || stat.isSymbolicLink()) throw Error('owner_placement_unsafe');
+  inode(stat.ino); return stat;
+}
+const sameLive = (a, b) => a.dev === b.dev && a.ino === b.ino;
+export function directoryPlacement(path) {
+  const stat = directory(path);
+  return Object.freeze({ location: realpathSync(path), ino: inode(stat.ino) });
+}
+export function ownerPlacement(path, role, logicalPath = path) {
+  const name = anchors[role];
+  if (!name) throw Error('owner_placement_role_invalid');
+  const before = directory(path), anchorPath = join(path, name);
+  let fd;
+  try {
+    const entry = lstatSync(anchorPath, { bigint: true });
+    if (!entry.isFile() || entry.isSymbolicLink() || entry.nlink !== 1n) throw Error('owner_placement_unsafe');
+    fd = openSync(anchorPath, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
+    const opened = fstatSync(fd, { bigint: true });
+    const after = lstatSync(anchorPath, { bigint: true });
+    if (!opened.isFile() || opened.nlink !== 1n || !sameLive(entry, opened)
+      || !after.isFile() || after.isSymbolicLink() || after.nlink !== 1n
+      || !sameLive(opened, after) || !sameLive(before, directory(path))) throw Error('owner_placement_changed');
+    return Object.freeze({ schema_version: 1, role, location: join(realpathSync(dirname(logicalPath)), basename(logicalPath)), directory_ino: inode(before.ino),
+      anchor: Object.freeze({ name, ino: inode(opened.ino) }) });
+  } finally { if (fd !== undefined) closeSync(fd); }
+}
+export function assertOwnerPlacement(binding, path, role, logicalPath = path) {
+  const actual = ownerPlacement(path, role, logicalPath);
+  if (!binding || JSON.stringify(binding) !== JSON.stringify(actual)) throw Error('owner_placement_changed');
+  return actual;
+}
+export function assertDirectoryPlacement(binding, path) {
+  const actual = directoryPlacement(path);
+  if (!binding || JSON.stringify(binding) !== JSON.stringify(actual)) throw Error('owner_placement_changed');
+  return actual;
+}

package/generated/plugins/agdf/runtime/create-agdf/runtime/core/lib/resources/canonical-init-plan.js

@@ -0,0 +1,34 @@
+import { readFileSync, lstatSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { resources } from './context.js';
+import { resolveLanguagePreference, languageConfigContent } from './language-preference.js';
+import { resolveArtefactTemplatePath } from './artefact-templates.js';
+import { containedRegularFile, hasSymlinkComponent } from '../control-state/contained-file.js';
+import { CURRENT_LAYOUT } from '../control-state/run-identity.js';
+
+// Fixed canonical seeds; callers supply only language.
+export function canonicalInitPlan(languagePreference, context = resources, { layout = CURRENT_LAYOUT } = {}) {
+  if (layout !== CURRENT_LAYOUT) throw Error('canonical_layout_unsupported');
+  const language = typeof languagePreference === 'object' && languagePreference !== null
+    ? languagePreference : resolveLanguagePreference(languagePreference, undefined, context);
+  const root = context.templatesRoot;
+  if (!root || lstatSync(root).isSymbolicLink()) throw Error('canonical_init_resources_unavailable');
+  const load = (base, relative) => {
+    if (hasSymlinkComponent(base, relative)) throw Error('canonical_init_resources_unsafe');
+    const file = containedRegularFile(base, relative);
+    if (file.status !== 'valid' || lstatSync(file.path).size > 131072) throw Error('canonical_init_resources_unavailable');
+    return readFileSync(file.path, 'utf8');
+  };
+  const files = [{ path: '.agdf/control/config.json', content: languageConfigContent(language, { control_layout: layout }) },
+    { path: '.agdf/control/README.md', content: load(dirname(root), 'README.md') }];
+  for (const store of ['runs', 'planned'])
+    files.push({ path: `.agdf/control/${store}/.gitkeep`, content: '' });
+  for (const name of ['SOT_REGISTRY.md', 'CONTEXT_GRAPH.md', 'AGENT_QUALITY_CONTRACTS.json', 'BRAND.md'])
+    files.push({ path: `.agdf/control/${name}`, content: load(root, name) });
+  for (const id of ['UR', 'BROWNFIELD_REVIEW', 'VERIFIED_CHANGE', 'PRD', 'UX_INTENT_DEFINITION', 'SD', 'TP', 'QA_REPORT', 'OR']) {
+    resolveArtefactTemplatePath(id, context);
+    files.push({ path: `.agdf/control/templates/artefacts/${id}.md`, content: load(root, `artefacts/${id}.md`) });
+  }
+  if (files.reduce((n, f) => n + Buffer.byteLength(f.content), 0) > 524288) throw Error('canonical_init_plan_budget_exceeded');
+  return files;
+}

package/generated/plugins/agdf/runtime/create-agdf/runtime/core/lib/resources/configuration.js

@@ -0,0 +1,92 @@
+import { CURRENT_LAYOUT } from '../control-state/run-identity.js';
+import { readFileSync, existsSync, statSync } from '../control-read/fs.js';
+import { join } from 'node:path';
+import { canonicalizeLanguageTag } from '../interaction-presentation.js';
+import { schemaDiagnostics, RUN_COMMAND_DESCRIPTORS } from '../control-state/run-command-schema.js';
+import { GATE_CHECK_VARIANTS } from '../control-inspect/selection.js';
+import { digest } from '../control-state/approval-command-contract.js';
+import { containedRegularFile, hasSymlinkComponent } from '../control-state/contained-file.js';
+import { currentInputResolution, isOriginalInputResolution } from '../control-state/input-resolution.js';
+
+export const PREFERENCE_KEYS = Object.freeze(['chat_language', 'artifact_language', 'presentation_route', 'gate_check_variant']);
+export const CONFIGURATION_PATH = '.agdf/control/config.json';
+const plain = value => value && typeof value === 'object' && !Array.isArray(value);
+export function configurationError(source, field, action = 'Correct the named configuration field and retry the original operation safely.') {
+  const code = field === 'control_layout' ? 'control_layout_unsupported' : 'configuration_invalid';
+  return Object.assign(Error(code), { code, facts: { code, dispatch: 'not_dispatched' },
+    diagnostic: { code, source, field, action } });
+}
+export function readPluginDefaults(generatedURL) {
+  try {
+    const bytes = readFileSync(new URL('plugins/agdf/meta/agdf-defaults.json', generatedURL), 'utf8');
+    const schema = JSON.parse(readFileSync(new URL('plugins/agdf/meta/agdf-defaults.schema.json', generatedURL), 'utf8'));
+    const document = JSON.parse(bytes);
+    if (schemaDiagnostics(document, schema).length || !PREFERENCE_KEYS.every(key => Object.hasOwn(schema.properties.preferences.properties, key))) throw Error();
+    const fields = schema.properties.preferences.properties;
+    if (JSON.stringify(fields.presentation_route.enum.slice().sort()) !== JSON.stringify(RUN_COMMAND_DESCRIPTORS['presentation.deliver'].payload_schema.properties.route.enum.slice().sort())
+      || JSON.stringify(fields.gate_check_variant.enum) !== JSON.stringify([null, ...GATE_CHECK_VARIANTS])) throw Error();
+    for (const key of ['chat_language', 'artifact_language']) if (!canonicalizeLanguageTag(document.preferences[key])) throw Error();
+    return { document, schema, digest: digest(bytes) };
+  } catch { throw Error('runtime_resources_unavailable'); }
+}
+export function resolveConfiguration(root, defaults, explicit = {}) {
+  const bound = currentInputResolution()?.configuration;
+  if (bound && bound.root === (root ?? null) && Object.keys(explicit).length === 0) return bound;
+  const source = { kind: 'plugin', path: 'meta/agdf-defaults.json', digest: defaults.digest };
+  let project = {}, configDigest = null, control = 'inactive';
+  if (root && existsSync(join(root, CONFIGURATION_PATH))) {
+    const projectSource = { kind: 'project', path: CONFIGURATION_PATH };
+    if (hasSymlinkComponent(root, CONFIGURATION_PATH) || containedRegularFile(root, CONFIGURATION_PATH).status !== 'valid') throw configurationError(projectSource, 'config', 'Use a regular contained project configuration file.');
+    let bytes;
+    try {
+      if (statSync(join(root, CONFIGURATION_PATH)).size > 65536) throw Error();
+      bytes = readFileSync(join(root, CONFIGURATION_PATH));
+      if (bytes.length > 65536) throw Error();
+      project = JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(bytes));
+    } catch { throw configurationError(projectSource, 'config', 'Correct the project configuration JSON; no operation was dispatched.'); }
+    if (!plain(project))
+      throw configurationError(projectSource, 'config', 'Restore the existing required language fields; defaults do not initialize project control.');
+    if (project.control_layout !== CURRENT_LAYOUT)
+      throw configurationError(projectSource, 'control_layout', 'Use the current explicit run-folders-v1 layout; old control stores are unsupported.');
+    for (const key of ['chat_language', 'artifact_language', 'runtime_language'])
+      if (typeof project[key] !== 'string' || !project[key].trim()) throw configurationError(projectSource, key, 'Restore the named required language field; defaults do not initialize project control.');
+    configDigest = digest(bytes); control = 'active';
+    if (!canonicalizeLanguageTag(project.runtime_language)) throw configurationError({ ...projectSource, digest: configDigest }, 'runtime_language');
+    for (const key of PREFERENCE_KEYS) if (Object.hasOwn(project, key)) {
+      if (schemaDiagnostics(project[key], defaults.schema.properties.preferences.properties[key]).length
+        || key.endsWith('_language') && !canonicalizeLanguageTag(project[key])) throw configurationError({ ...projectSource, digest: configDigest }, key);
+    }
+  }
+  const values = {}, sources = {};
+  for (const key of PREFERENCE_KEYS) {
+    let value;
+    if (Object.hasOwn(explicit, key)) {
+      value = explicit[key]; sources[key] = { kind: 'explicit' };
+      if (schemaDiagnostics(value, defaults.schema.properties.preferences.properties[key]).length) throw configurationError(sources[key], key, 'Correct the explicit value; an invalid value is never defaulted.');
+    } else if (Object.hasOwn(project, key)) { value = project[key]; sources[key] = { kind: 'project', path: CONFIGURATION_PATH, digest: configDigest }; }
+    else { value = defaults.document.preferences[key]; sources[key] = source; }
+    values[key] = key.endsWith('_language') ? canonicalizeLanguageTag(value) : value;
+    if (key.endsWith('_language') && !values[key]) throw configurationError(sources[key], key);
+  }
+  return Object.freeze({ root: root ?? null, control, config_digest: configDigest, values: Object.freeze(values), sources: Object.freeze(sources),
+    control_layout: control === 'active' ? project.control_layout : null,
+    defaults_digest: defaults.digest });
+}
+export function assertConfigurationCurrent(snapshot) {
+  if (!snapshot?.root) return;
+  const path = join(snapshot.root, CONFIGURATION_PATH);
+  try {
+    if (existsSync(path) && statSync(path).size > 65536) throw Error();
+    const current = existsSync(path) ? digest(readFileSync(path)) : null;
+    if (current === snapshot.config_digest && (!existsSync(path) || !hasSymlinkComponent(snapshot.root, CONFIGURATION_PATH))) return;
+  } catch { /* Changed/unreadable configuration cannot select new values mid-effect. */ }
+  throw Object.assign(Error('snapshot_stale'), { facts: { code: 'snapshot_stale', dispatch: 'not_dispatched' } });
+}
+export function assertInputConfigurationCurrent(root) {
+  const snapshot = currentInputResolution()?.configuration;
+  if (snapshot?.root && snapshot.root !== root) throw Error('target_binding_mismatch');
+  if (snapshot && !isOriginalInputResolution()) assertConfigurationCurrent(snapshot);
+}
+export function effectiveConfiguration(snapshot, binding = 'current') {
+  return { binding, values: snapshot.values, sources: snapshot.sources, constants: 'contract_owned', authorizes: false };
+}

package/generated/plugins/agdf/runtime/create-agdf/runtime/core/lib/resources/context.js

@@ -1,9 +1,9 @@
-import { existsSync, readFileSync } from "../control-read/fs.js";
-import { join } from "node:path";
+import { readFileSync } from "../control-read/fs.js";
 import { fileURLToPath } from "node:url";
 import { canonicalizeLanguageTag, resolvePresentationLocale } from "../interaction-presentation.js";
 import { validateInteractionCatalog } from "../interaction-catalog-validation.js";
 import { packageURL, generatedURL, contractsURL, templatesURL } from "./binding.js";
+import { readPluginDefaults, resolveConfiguration } from './configuration.js';
 
 function freeze(value) {
   if (value && typeof value === "object") { for (const entry of Object.values(value)) freeze(entry); Object.freeze(value); }
@@ -30,6 +30,7 @@ export function createResourceContext({ packageURL, generatedURL, contractsURL,
     templatesRoot: templatesURL instanceof URL ? fileURLToPath(templatesURL) : null,
     pluginDefinition,
     interactionLocales,
+    defaults: readPluginDefaults(generatedURL),
   });
 }
 export const resources = createResourceContext({ packageURL, generatedURL, contractsURL, templatesURL });
@@ -42,21 +43,16 @@ export function configuredLanguage(value, context = resources) {
   return normalized;
 }
 export function resolveConfiguredChatLanguage(targetDir, context = resources) {
-  const configPath = join(targetDir, ".agdf", "control", "config.json");
-  if (!existsSync(configPath)) return context.interactionLocales.fallbackLocale;
-  try { return resolvePresentationLocale(context.interactionLocales, JSON.parse(readFileSync(configPath, "utf8")).chat_language); }
-  catch { return context.interactionLocales.fallbackLocale; }
+  return resolvePresentationLocale(context.interactionLocales, resolveConfiguration(targetDir, context.defaults).values.chat_language);
 }
-// Missing or invalid config means English artefacts.
-export function resolveConfiguredArtifactLanguage(targetDir) {
-  try { return canonicalizeLanguageTag(JSON.parse(readFileSync(join(targetDir, ".agdf", "control", "config.json"), "utf8")).artifact_language).split("-")[0] || "en"; }
-  catch { return "en"; }
+export function resolveConfiguredArtifactLanguage(targetDir, context = resources) {
+  return resolveConfiguration(targetDir, context.defaults).values.artifact_language.split('-')[0];
 }
 
 // Shared by artefact authoring and approval rendering; the selected locale may override
 // the configured chat default, but never changes the persisted artefact language.
 export function resolveArtifactPresentationLanguages(targetDir, requestedLanguage, context = resources) {
-  const artifactLanguage = resolveConfiguredArtifactLanguage(targetDir);
+  const artifactLanguage = resolveConfiguredArtifactLanguage(targetDir, context);
   const presentationLanguage = requestedLanguage
     ? resolvePresentationLocale(context.interactionLocales, requestedLanguage)
     : resolveConfiguredChatLanguage(targetDir, context);

package/generated/plugins/agdf/runtime/create-agdf/runtime/core/lib/resources/language-preference.js

@@ -0,0 +1,59 @@
+import { CURRENT_LAYOUT } from '../control-state/run-identity.js';
+import process from "node:process";
+import { canonicalizeLanguageTag } from "../interaction-presentation.js";
+import { configuredLanguage, resources } from "./context.js";
+
+export function canonicalizeDetectedSystemLocale(value) {
+  if (typeof value !== "string") return "";
+  const candidate = value.trim().split(":", 1)[0];
+  if (!candidate || /^(?:C|POSIX)(?:\.|$)/iu.test(candidate)) return "";
+  const withoutModifier = candidate.split("@", 1)[0];
+  const withoutEncoding = withoutModifier.split(".", 1)[0];
+  return canonicalizeLanguageTag(withoutEncoding.replaceAll("_", "-"));
+}
+
+export function detectSystemLocale(env = process.env) {
+  const envLocale = env.LC_ALL || env.LC_MESSAGES || env.LANG || env.LANGUAGE || "";
+  if (envLocale) return envLocale;
+  try {
+    return Intl.DateTimeFormat().resolvedOptions().locale || "";
+  } catch {
+    return "";
+  }
+}
+
+export function resolveLanguagePreference(explicitLanguage, env = process.env, context = resources) {
+  const explicit = configuredLanguage(explicitLanguage, context);
+  if (explicit) {
+    return {
+      artifact_language: explicit,
+      chat_language: explicit,
+      runtime_language: "en",
+      source: "parameter",
+      detected_locale: detectSystemLocale(env) || "unknown",
+    };
+  }
+
+  const detectedLocale = detectSystemLocale(env);
+  const detectedTag = canonicalizeDetectedSystemLocale(detectedLocale);
+  const detected = configuredLanguage(detectedTag, context);
+  return {
+    artifact_language: detected || context.defaults.document.preferences.artifact_language,
+    chat_language: detected || context.defaults.document.preferences.chat_language,
+    runtime_language: "en",
+    source: detectedLocale ? "system_locale" : "default",
+    detected_locale: detectedLocale || "unknown",
+  };
+}
+
+export function languageConfigContent(languagePreference, existing = { control_layout: CURRENT_LAYOUT }) {
+  return `${JSON.stringify({
+    ...existing,
+    ...languagePreference,
+    artifact_language: languagePreference.artifact_language,
+    chat_language: languagePreference.chat_language,
+    runtime_language: languagePreference.runtime_language,
+    source: languagePreference.source,
+    detected_locale: languagePreference.detected_locale,
+  }, null, 2)}\n`;
+}

package/generated/plugins/agdf/runtime/create-agdf/runtime/core/lib/runtime/mcp-owner-protocol.js

@@ -0,0 +1,102 @@
+import { createHash } from 'node:crypto';
+export const GENERATION_LIMITS = Object.freeze({ slots: 3, input: 65536, result: 1048576, qualify: 30000, close: 10000, receipts: 256, routes: 4096 });
+const uuid = value => typeof value === 'string' && /^[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}$/u.test(value);
+const fields = ['schema_version', 'owner_epoch', 'generation_id', 'request_id', 'kind', 'original_operation_id', 'payload', 'context'];
+export function validGenerationMessage(value, { epoch, generation, reply = false } = {}) {
+  if (!finiteJson(value) || !value || typeof value !== 'object' || Array.isArray(value) || Object.keys(value).sort().join() !== [...fields].sort().join()
+    || value.schema_version !== '1' || value.owner_epoch !== epoch || value.generation_id !== generation
+    || !uuid(value.request_id) || !(value.original_operation_id === null || uuid(value.original_operation_id))
+    || !Number.isSafeInteger(value.generation_id) || value.generation_id < 1
+    || !(reply ? ['qualified', 'result', 'status', 'closed', 'failure'] : ['qualify', 'invoke', 'session_inspect', 'shutdown']).includes(value.kind)
+    || !value.context || typeof value.context !== 'object' || Array.isArray(value.context)) return false;
+  if (['status', 'closed'].includes(value.kind) && (!value.payload || !['views', 'inflight', 'executor', 'uncertain'].every(key =>
+    Number.isSafeInteger(value.payload[key]) && value.payload[key] >= 0) || typeof value.payload.closing !== 'boolean' || value.kind === 'closed' && value.payload.closing !== true)) return false;
+  try { return Buffer.byteLength(JSON.stringify(value)) <= (reply ? GENERATION_LIMITS.result : GENERATION_LIMITS.input); } catch { return false; }
+}
+export function generationMessage(epoch, generation, kind, payload, context = {}, original = null, requestId) {
+  return JSON.parse(JSON.stringify({ schema_version: '1', owner_epoch: epoch, generation_id: generation, request_id: requestId,
+    kind, original_operation_id: original, payload, context }));
+}
+export function generationManifest(runtime, uiDigest, sdkDigest) {
+  if (typeof runtime.toolErrorContract !== 'string' || !runtime.toolErrorContract
+    || typeof runtime.projectToolResult !== 'function' || typeof runtime.consumeToolResult !== 'function'
+    || typeof runtime.normalizeFailure !== 'function') throw Error('generation_manifest_incompatible');
+  // Stable transport shape, never business eligibility or a human-origin proof.
+  return { schema_version: '1', mode: runtime.mode ?? 'headless', sdk_digest: sdkDigest,
+    protocol: 'mcp-sdk/2:stdio-legacy-and-modern', tool_error_contract: runtime.toolErrorContract,
+    tools: runtime.tools.map(tool => ({ name: tool.name, definition: tool.definition })),
+    resource: runtime.ui ? { uri: runtime.ui.uri, mimeType: runtime.ui.mimeType, digest: uiDigest } : null,
+    command_groups: [...(runtime.trustedContext.commandGroups ?? [])] };
+}
+export const manifestDigest = manifest => createHash('sha256').update(JSON.stringify(manifest)).digest('hex');
+
+const FAILURE_REASONS = new Set([
+  'generation_unavailable', 'generation_input_limit', 'generation_response_unknown', 'generation_connection_lost',
+  'generation_capacity_protected', 'generation_manifest_incompatible', 'generation_result_limit',
+  'generation_request_capacity', 'generation_already_initialized', 'generation_work_protected',
+  'generation_cleanup_unconfirmed', 'resource_denied', 'runtime_provenance_invalid', 'runtime_version_mismatch',
+  'dispatch_busy', 'dispatch_cancelled', 'dispatch_timeout', 'dispatch_worker_failed', 'dispatch_worker_termination_unconfirmed',
+  'runtime_publication_unowned', 'runtime_candidate_manifest_invalid', 'runtime_candidate_unowned', 'runtime_candidate_digest_mismatch',
+  'AGDF_MCP_EXECUTABLE_CLAIM_INVALID', 'AGDF_MCP_EXECUTABLE_CLAIM_CONTENDED',
+  'AGDF_MCP_EXECUTABLE_CLAIM_LOCK_UNCONFIRMED', 'AGDF_MCP_PUBLICATION_DEADLINE_EXCEEDED',
+]);
+export function generationFailureReason(error) {
+  const reason = error?.code ?? error?.message;
+  return FAILURE_REASONS.has(reason) ? reason : 'generation_runtime_failed';
+}
+
+// Private owner transport. JSON strings deliberately preserve the old fork wire
+// semantics instead of accepting Worker structured-clone capabilities.
+export const OWNER_EXECUTION_MODEL = 'owner_threads_v1';
+// The fixed owner header is separate from the unchanged generation wire
+// budgets. Wrapping a previously legal 64 KiB/1 MiB packet must not reject it.
+export const OWNER_LIMITS = Object.freeze({ frames: 64, bytes: 3 * GENERATION_LIMITS.result, history: 8192,
+  header: 512, inputFrame: GENERATION_LIMITS.input + 512, resultFrame: GENERATION_LIMITS.result + 512 });
+const ownerFields = ['schema_version', 'token', 'connection_epoch', 'request_id', 'kind', 'generation_epoch', 'generation_id', 'publication_id', 'payload'];
+const ownerKinds = new Set(['open', 'opened', 'send', 'message', 'exit', 'failure', 'stop', 'closed']);
+export function finiteJson(value, depth = 0, seen = new Set()) {
+  if (depth > 64) return false;
+  if (value === null || typeof value === 'string' || typeof value === 'boolean') return true;
+  if (typeof value === 'number') return Number.isFinite(value);
+  if (!value || typeof value !== 'object' || seen.has(value)) return false;
+  const array = Array.isArray(value);
+  if (Object.getPrototypeOf(value) !== (array ? Array.prototype : Object.prototype)) return false;
+  const descriptors = Object.getOwnPropertyDescriptors(value), keys = Object.keys(descriptors);
+  if (Reflect.ownKeys(value).length !== keys.length) return false;
+  if (array && (keys.length !== value.length + 1 || keys.some(key => key !== 'length' && !/^(?:0|[1-9][0-9]*)$/u.test(key)))) return false;
+  seen.add(value);
+  for (const key of keys) {
+    if (array && key === 'length') continue;
+    const d = descriptors[key];
+    if (!d.enumerable || !Object.hasOwn(d, 'value') || !finiteJson(d.value, depth + 1, seen)) { seen.delete(value); return false; }
+  }
+  seen.delete(value); return true;
+}
+export function ownerFrame(binding, kind, payload, requestId, generation = {}) {
+  return { schema_version: '1', token: binding.token, connection_epoch: binding.connection_epoch,
+    request_id: requestId, kind, generation_epoch: generation.epoch ?? null,
+    generation_id: generation.generation ?? null, publication_id: generation.publication_id ?? binding.publication_id, payload };
+}
+export function encodeOwnerFrame(value, binding, { reply = false } = {}) {
+  if (!finiteJson(value) || Object.keys(value).sort().join() !== [...ownerFields].sort().join()
+    || value.schema_version !== '1' || value.token !== binding.token || value.connection_epoch !== binding.connection_epoch
+    || !uuid(value.token) || !uuid(value.connection_epoch) || !uuid(value.request_id) || !ownerKinds.has(value.kind)
+    || !(reply ? ['opened', 'message', 'exit', 'failure', 'stop'] : ['open', 'send', 'closed']).includes(value.kind)
+    || !/^[0-9a-f]{64}$/u.test(value.publication_id ?? '')
+    || !(value.generation_epoch === null && value.generation_id === null
+      || uuid(value.generation_epoch) && Number.isSafeInteger(value.generation_id) && value.generation_id > 0)) throw Error('generation_input_limit');
+  if (Buffer.byteLength(JSON.stringify(value.payload)) > (reply ? GENERATION_LIMITS.result : GENERATION_LIMITS.input)) throw Error('generation_input_limit');
+  if (['send', 'message'].includes(value.kind) && (!validGenerationMessage(value.payload, { epoch: value.generation_epoch, generation: value.generation_id, reply: value.kind === 'message' })
+    || value.payload.request_id !== value.request_id)) throw Error('generation_input_limit');
+  const wire = JSON.stringify(value);
+  if (Buffer.byteLength(wire) > (reply ? OWNER_LIMITS.resultFrame : OWNER_LIMITS.inputFrame)) throw Error('generation_input_limit');
+  return wire;
+}
+export function decodeOwnerFrame(wire, binding, options) {
+  if (typeof wire !== 'string' || Buffer.byteLength(wire) > (options?.reply ? OWNER_LIMITS.resultFrame : OWNER_LIMITS.inputFrame)) throw Error('generation_input_limit');
+  const value = JSON.parse(wire); encodeOwnerFrame(value, binding, options); return value;
+}
+export function publicationSelector(runtime) {
+  return { schema_version: '1', publication_id: runtime.publication_id, version: runtime.version,
+    server_digest: runtime.digest, dispatcher_digest: runtime.dispatcherDigest, sdk_digest: runtime.sdkDigest };
+}