@avantf/dsh-identity 0.0.0-stage → 0.1.0

package/lib/index.js

@@ -0,0 +1,1517 @@
+// lib/index.js
+import { PERSONA_PREFIX_SECTION } from "@deepseek-ai/dsh-system-prompt";
+import z2 from "@deepseek-ai/schemastery";
+import { readFileSync as readFileSync3 } from "node:fs";
+
+// lib/base.js
+import { loadFramework } from "./envinit-bootstrap.js";
+
+// lib/interface_gate.js
+function member(module, name2) {
+  try {
+    return module?.[name2];
+  } catch {
+    return void 0;
+  }
+}
+function cannotTell(reason) {
+  return { status: "cannot-tell", reason };
+}
+function baseIsUsable(verdict) {
+  return verdict.status !== "incompatible";
+}
+var BAKED_CANDIDATES = ["./interface-version.json", "../interface-version.json"];
+function requirementOf(read, bakedUrl) {
+  const candidates = bakedUrl === void 0 ? BAKED_CANDIDATES.map((relative) => new URL(relative, import.meta.url)) : [bakedUrl];
+  for (const url of candidates) {
+    let requirement;
+    try {
+      requirement = read(url);
+    } catch {
+      continue;
+    }
+    const version = requirement?.interfaceVersion;
+    if (typeof version === "number" && Number.isInteger(version) && version > 0)
+      return { interfaceVersion: version };
+  }
+  return void 0;
+}
+function interfaceVerdict(module, bakedUrl) {
+  const check = member(module, "checkInterface");
+  const read = member(module, "readInterfaceRequirement");
+  if (typeof check !== "function" || typeof read !== "function") {
+    return cannotTell("the loaded base has no interface gate (checkInterface / readInterfaceRequirement missing) — it predates the runtime interface contract, so which generation it implements cannot be told");
+  }
+  const requirement = requirementOf(read, bakedUrl);
+  if (requirement === void 0) {
+    return cannotTell("this build has no baked interface requirement (lib/interface-version.json is missing or malformed), so the runtime interface gate cannot run");
+  }
+  let verdict;
+  try {
+    verdict = check(requirement.interfaceVersion, module);
+  } catch {
+    return cannotTell("the loaded base threw while judging the interface generation");
+  }
+  const status = verdict?.status;
+  if (status !== "ok" && status !== "incompatible" && status !== "cannot-tell") {
+    return cannotTell("the loaded base returned no usable interface verdict");
+  }
+  return verdict;
+}
+function warn(log, message) {
+  try {
+    log?.warn(message);
+  } catch {
+  }
+}
+function reasonOf(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function gateOrDegrade(module, log, words) {
+  const verdict = interfaceVerdict(module);
+  if (!baseIsUsable(verdict)) {
+    warn(log, `${words.prefix} WARNING — interface: ${verdict.reason ?? "the loaded base implements another interface generation"}; the base's shared capabilities are NOT used (${words.withheld}) and the plugin mounts anyway`);
+    return false;
+  }
+  if (verdict.status === "cannot-tell") {
+    warn(log, `${words.prefix} WARNING — interface: ${verdict.reason ?? "the interface generation cannot be told"}; using the loaded base anyway ("cannot tell" is never "incompatible")`);
+  }
+  return true;
+}
+async function loadGuarded(options, loadOnce, log, words) {
+  try {
+    return await loadOnce(options);
+  } catch (error) {
+    warn(log, `${words.prefix} WARNING — environment initialisation failed (${reasonOf(error)}); ${words.loadFailure}`);
+    return void 0;
+  }
+}
+function createLoadCache(guarded) {
+  let loaded;
+  let loading;
+  return {
+    load(options) {
+      if (loaded !== void 0)
+        return Promise.resolve(loaded);
+      if (loading !== void 0)
+        return loading;
+      loading = guarded(options).then((runtime) => {
+        if (runtime === void 0)
+          loading = void 0;
+        else
+          loaded = runtime;
+        return runtime;
+      }, () => {
+        loading = void 0;
+        return void 0;
+      });
+      return loading;
+    },
+    clear() {
+      loaded = void 0;
+      loading = void 0;
+    }
+  };
+}
+function stillActive(ctx) {
+  const fiber = ctx?.fiber;
+  return fiber === void 0 || fiber.uid !== null;
+}
+
+// lib/paths.js
+import { homedir } from "node:os";
+import { join } from "node:path";
+var IDENTITY_FILES = ["IDENTITY", "SOUL", "RULES"];
+var LOCALE_IDS = ["zh", "en"];
+var FALLBACK_LOCALE = "en";
+var PRESET_ID_PATTERN = /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/u;
+function expandHomeMirror(path, home = homedir()) {
+  if (path === "~")
+    return home;
+  return path.startsWith("~/") ? join(home, path.slice(2)) : path;
+}
+function resolveDataHomeMirror(input = {}) {
+  const layer5 = input.explicit?.trim() ?? "";
+  const env = input.env ?? process.env;
+  const fromEnv = env["AVANTF_HOME"]?.trim() ?? "";
+  const layer2 = input.configured?.trim() ?? "";
+  const base = layer5 !== "" ? layer5 : fromEnv !== "" ? fromEnv : layer2 !== "" ? layer2 : join(homedir(), ".avantf");
+  return expandHomeMirror(base);
+}
+function identityRoot(dataHome) {
+  return join(dataHome, "identity");
+}
+function profileDir(root, profile) {
+  return join(root, "profiles", profile);
+}
+function presetsRoot(root) {
+  return join(root, "presets");
+}
+function profileEditsRoot(root, profile) {
+  return join(profileDir(root, profile), ".edits");
+}
+function profileEditDir(root, profile, id) {
+  return join(profileEditsRoot(root, profile), id);
+}
+function presetLocaleDir(root, id, locale) {
+  return join(presetsRoot(root), id, locale);
+}
+function provisionMarker(root) {
+  return join(root, ".provisioned");
+}
+
+// lib/base.js
+var FRAMEWORK_PACKAGE = "@avantf/dsh-plugin-base";
+var DEGRADE_WORDS = {
+  prefix: "envinit:",
+  loadFailure: "the identity plugin mounts with its own data-home resolution and no shared base capabilities",
+  withheld: `the family data-home rule comes from this plugin's own mirror instead of ${FRAMEWORK_PACKAGE}`
+};
+async function loadBaseOnce(options) {
+  const log = options.log;
+  const module = options.framework ?? await loadFramework({
+    logger: {
+      warn: (message) => {
+        log?.warn(`${FRAMEWORK_PACKAGE}: ${message}`);
+      },
+      info: (message) => {
+        log?.info(`${FRAMEWORK_PACKAGE}: ${message}`);
+      }
+    }
+  });
+  if (module === void 0) {
+    log?.warn(`${FRAMEWORK_PACKAGE} could not be made available; the identity plugin mounts anyway and resolves the data home with its own mirror`);
+    return void 0;
+  }
+  if (!gateOrDegrade(module, log, DEGRADE_WORDS))
+    return void 0;
+  return { module, dataHome: (input) => readDataHome(module, input) };
+}
+function readDataHome(module, input) {
+  try {
+    if (typeof module.resolveDataHome === "function")
+      return module.resolveDataHome(input);
+  } catch {
+  }
+  return resolveDataHomeMirror(input);
+}
+var cache = createLoadCache((options) => loadGuarded(options, loadBaseOnce, options.log, DEGRADE_WORDS));
+function loadBase(options = {}) {
+  return cache.load(options);
+}
+
+// lib/gateway.js
+import { Remote, TypertRemoteService } from "@deepseek-ai/dsh-typert-protocol";
+
+// lib/presets.js
+import { copyFileSync, existsSync, mkdirSync, readFileSync, readdirSync, rmSync } from "node:fs";
+import { join as join2 } from "node:path";
+import { fileURLToPath } from "node:url";
+
+// lib/atomic-write.js
+import { renameSync, unlinkSync, writeFileSync } from "node:fs";
+function writeFileAtomically(path, text2) {
+  const temporary = `${path}.tmp-${String(process.pid)}`;
+  try {
+    writeFileSync(temporary, text2, "utf8");
+    renameSync(temporary, path);
+  } catch (error) {
+    try {
+      unlinkSync(temporary);
+    } catch {
+    }
+    throw error;
+  }
+}
+
+// lib/presets.js
+var LOCALE_PATTERN = /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/u;
+var DEFAULT_PRESET_ID = "assistant";
+function isValidPresetId(id) {
+  return PRESET_ID_PATTERN.test(id);
+}
+function isValidLocale(locale) {
+  return LOCALE_PATTERN.test(locale);
+}
+function resolveAssetsDir(from = import.meta.url) {
+  for (const relative of ["./assets/presets", "../assets/presets"]) {
+    try {
+      const candidate = fileURLToPath(new URL(relative, from));
+      if (existsSync(candidate))
+        return candidate;
+    } catch {
+    }
+  }
+  return void 0;
+}
+function packagedPresetIds(assetsDir) {
+  try {
+    return readdirSync(assetsDir, { withFileTypes: true }).filter((entry) => entry.isDirectory() && isValidPresetId(entry.name)).map((entry) => entry.name).sort((left, right) => left.localeCompare(right));
+  } catch {
+    return [];
+  }
+}
+function materializePresets(options) {
+  const copied = [];
+  const skipped = [];
+  const target = presetsRoot(options.root);
+  const marker = provisionMarker(options.root);
+  const packaged = packagedPresetIds(options.assetsDir);
+  const released = readReleasedPresets(marker);
+  const known = released ?? packaged;
+  try {
+    mkdirSync(target, { recursive: true });
+    for (const id of packaged) {
+      const destination = join2(target, id);
+      if (known.includes(id)) {
+        skipped.push(id);
+        continue;
+      }
+      if (copyMissing(join2(options.assetsDir, id), destination))
+        copied.push(id);
+      else
+        skipped.push(id);
+    }
+    writeFileAtomically(marker, `${JSON.stringify({
+      version: options.version,
+      at: (/* @__PURE__ */ new Date()).toISOString(),
+      presets: [.../* @__PURE__ */ new Set([...known, ...copied])].sort((left, right) => left.localeCompare(right)),
+      copied
+    }, null, 2)}
+`);
+  } catch (error) {
+    options.logger?.warn(`releasing the built-in presets into ${target} failed (${reasonOf2(error)}); the plugin mounts with the presets already on disk`);
+    return { copied, skipped };
+  }
+  if (copied.length > 0)
+    options.logger?.info(`released built-in presets: ${copied.join(", ")}`);
+  return { copied, skipped };
+}
+function copyMissing(source, destination) {
+  if (!existsSync(source))
+    return false;
+  let wrote = false;
+  mkdirSync(destination, { recursive: true });
+  for (const entry of readdirSync(source, { withFileTypes: true })) {
+    const from = join2(source, entry.name);
+    const to = join2(destination, entry.name);
+    if (entry.isDirectory()) {
+      if (copyMissing(from, to))
+        wrote = true;
+      continue;
+    }
+    if (existsSync(to))
+      continue;
+    copyFileSync(from, to);
+    wrote = true;
+  }
+  return wrote;
+}
+function readReleasedPresets(marker) {
+  let raw;
+  try {
+    raw = readFileSync(marker, "utf8");
+  } catch {
+    return [];
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed.presets))
+      return void 0;
+    return parsed.presets.filter((id) => typeof id === "string" && isValidPresetId(id));
+  } catch {
+    return void 0;
+  }
+}
+function listPresets(root) {
+  const base = presetsRoot(root);
+  let ids = [];
+  try {
+    ids = readdirSync(base, { withFileTypes: true }).filter((entry) => entry.isDirectory() && isValidPresetId(entry.name)).map((entry) => entry.name);
+  } catch {
+    return [];
+  }
+  return ids.sort((left, right) => left.localeCompare(right)).map((id) => {
+    let locales = [];
+    try {
+      locales = readdirSync(join2(base, id), { withFileTypes: true }).filter((entry) => entry.isDirectory() && isValidLocale(entry.name)).map((entry) => entry.name).sort((left, right) => left.localeCompare(right));
+    } catch {
+      locales = [];
+    }
+    return { id, locales };
+  });
+}
+function resolvingLocale(root, id, requested) {
+  if (isValidLocale(requested) && existsSync(presetLocaleDir(root, id, requested)))
+    return requested;
+  if (existsSync(presetLocaleDir(root, id, FALLBACK_LOCALE)))
+    return FALLBACK_LOCALE;
+  return void 0;
+}
+function identityFilesIn(dir) {
+  return IDENTITY_FILES.map((name2) => {
+    const file = `${name2}.md`;
+    let text2 = "";
+    try {
+      text2 = readFileSync(join2(dir, file), "utf8");
+    } catch {
+      text2 = "";
+    }
+    return { name: name2, file, text: text2, present: text2.trim() !== "", bytes: Buffer.byteLength(text2, "utf8") };
+  });
+}
+function writeIdentityFiles(dir, files) {
+  const written = [];
+  const missing = [];
+  let ready = false;
+  for (const file of files) {
+    if (!file.present) {
+      missing.push(file.file);
+      continue;
+    }
+    if (!ready) {
+      mkdirSync(dir, { recursive: true });
+      ready = true;
+    }
+    writeFileAtomically(join2(dir, file.file), file.text);
+    written.push(file.file);
+  }
+  return { written, missing };
+}
+function readPreset(root, id, requestedLocale) {
+  if (!isValidPresetId(id))
+    return void 0;
+  const requested = isValidLocale(requestedLocale) ? requestedLocale : FALLBACK_LOCALE;
+  const resolved = resolvingLocale(root, id, requested);
+  if (resolved === void 0)
+    return void 0;
+  return {
+    id,
+    requestedLocale: requested,
+    resolvedLocale: resolved,
+    fellBack: resolved !== requested,
+    files: identityFilesIn(presetLocaleDir(root, id, resolved))
+  };
+}
+function writePresetFile(root, id, locale, name2, text2) {
+  if (!isValidPresetId(id))
+    throw new Error(`invalid preset id: ${id}`);
+  if (!isValidLocale(locale))
+    throw new Error(`invalid locale: ${locale}`);
+  const dir = presetLocaleDir(root, id, locale);
+  mkdirSync(dir, { recursive: true });
+  writeFileAtomically(join2(dir, `${name2}.md`), text2);
+}
+function deletePreset(root, id) {
+  if (!isValidPresetId(id))
+    return false;
+  const dir = join2(presetsRoot(root), id);
+  if (!existsSync(dir))
+    return false;
+  rmSync(dir, { recursive: true, force: true });
+  return true;
+}
+function applyPresetToProfile(options) {
+  const preset = readPreset(options.root, options.id, options.locale);
+  if (preset === void 0)
+    return void 0;
+  const { written, missing } = writeIdentityFiles(profileDir(options.root, options.profile), preset.files);
+  return { resolvedLocale: preset.resolvedLocale, fellBack: preset.fellBack, written, missing };
+}
+function seedProfileIfEmpty(options) {
+  const dir = profileDir(options.root, options.profile);
+  if (identityFilesIn(dir).some((file) => file.present))
+    return { seeded: false, written: [] };
+  const available = listPresets(options.root).map((preset) => preset.id);
+  const id = available.includes(DEFAULT_PRESET_ID) ? DEFAULT_PRESET_ID : available[0];
+  if (id === void 0) {
+    return { seeded: false, written: [], error: "no preset is available to seed this identity; apply a preset or write the files" };
+  }
+  const applied = applyPresetToProfile({ root: options.root, profile: options.profile, id, locale: options.locale });
+  if (applied === void 0)
+    return { seeded: false, written: [], error: `preset could not be read: ${id}` };
+  return {
+    seeded: true,
+    preset: id,
+    resolvedLocale: applied.resolvedLocale,
+    fellBack: applied.fellBack,
+    written: applied.written
+  };
+}
+function readProfileEdit(options) {
+  if (!isValidPresetId(options.id))
+    return void 0;
+  const dir = profileEditDir(options.root, options.profile, options.id);
+  if (!existsSync(dir))
+    return void 0;
+  const files = identityFilesIn(dir);
+  return { files, bytes: files.reduce((total, file) => total + file.bytes, 0) };
+}
+function snapshotProfileEdit(options) {
+  if (!isValidPresetId(options.id))
+    return void 0;
+  const files = options.files ?? identityFilesIn(profileDir(options.root, options.profile));
+  const { written } = writeIdentityFiles(profileEditDir(options.root, options.profile, options.id), files);
+  return { written };
+}
+function applyProfileEditToProfile(options) {
+  const edit = readProfileEdit(options);
+  if (edit === void 0)
+    return void 0;
+  const { written } = writeIdentityFiles(profileDir(options.root, options.profile), edit.files);
+  return { written };
+}
+function dropProfileEdit(options) {
+  if (!isValidPresetId(options.id))
+    return false;
+  const dir = profileEditDir(options.root, options.profile, options.id);
+  if (!existsSync(dir))
+    return false;
+  rmSync(dir, { recursive: true, force: true });
+  return true;
+}
+function profileDiffersFromPreset(options) {
+  if (!isValidPresetId(options.id))
+    return false;
+  const files = options.effectiveFiles ?? identityFilesIn(profileDir(options.root, options.profile));
+  const effective = files.map((file) => file.text.trim());
+  const locales = [.../* @__PURE__ */ new Set([options.locale, ...LOCALE_IDS])];
+  const matchesSomeLocale = locales.some((locale) => {
+    const preset = readPreset(options.root, options.id, locale);
+    if (preset === void 0)
+      return false;
+    return IDENTITY_FILES.every((name2, index) => {
+      const file = preset.files.find((candidate) => candidate.file === `${name2}.md`);
+      return effective[index] === (file?.present === true ? file.text.trim() : "");
+    });
+  });
+  return !matchesSomeLocale;
+}
+function saveProfileAsPreset(options) {
+  if (!isValidPresetId(options.id))
+    return void 0;
+  const locale = isValidLocale(options.locale) ? options.locale : FALLBACK_LOCALE;
+  const dir = presetLocaleDir(options.root, options.id, locale);
+  if (existsSync(dir))
+    return void 0;
+  const files = identityFilesIn(profileDir(options.root, options.profile));
+  const { written } = writeIdentityFiles(dir, files);
+  return { written };
+}
+function reasonOf2(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// lib/wire.js
+import * as z from "zod";
+var PACKAGE = "@avantf/dsh-identity";
+var NAMESPACE = "avantfIdentity";
+function strict(schema, typeSymbol) {
+  return { mode: "strict", typeSymbol, schema, create: () => schema };
+}
+var endpointId = (method) => `${PACKAGE}#${NAMESPACE}/${method}`;
+var fieldSymbol = (method, field) => `${PACKAGE}#${NAMESPACE}/${method}:${field}`;
+function direct(method, args) {
+  return {
+    id: endpointId(method),
+    service: NAMESPACE,
+    namespace: NAMESPACE,
+    method,
+    invocation: { kind: "direct" },
+    parameters: [{ name: "args", wire: "args", source: "json", codec: strict(args, fieldSymbol(method, "args")) }],
+    result: strict(z.any(), fieldSymbol(method, "result"))
+  };
+}
+function directNoArgs(method) {
+  return {
+    id: endpointId(method),
+    service: NAMESPACE,
+    namespace: NAMESPACE,
+    method,
+    invocation: { kind: "direct" },
+    parameters: [],
+    result: strict(z.any(), fieldSymbol(method, "result"))
+  };
+}
+var optionalText = z.string().optional();
+var text = z.string();
+var descriptors = [
+  direct("status", z.object({ locale: optionalText })),
+  directNoArgs("listPresets"),
+  directNoArgs("readProfile"),
+  direct("writeProfileFile", z.object({ name: text, text })),
+  direct("ensureProfile", z.object({ locale: optionalText })),
+  direct("applyPreset", z.object({ id: text, locale: optionalText })),
+  direct("resetToPreset", z.object({ id: text, locale: optionalText })),
+  direct("saveAsPreset", z.object({ id: text, locale: optionalText })),
+  direct("readPreset", z.object({ id: text, locale: optionalText })),
+  direct("writePresetFile", z.object({ id: text, name: text, text, locale: optionalText })),
+  direct("deletePreset", z.object({ id: text }))
+];
+var fileTextSchema = z.object({
+  name: text,
+  file: text,
+  text,
+  present: z.boolean(),
+  bytes: z.number()
+});
+var fileStatusSchema = z.object({
+  name: text,
+  file: text,
+  path: text,
+  present: z.boolean(),
+  bytes: z.number()
+});
+var presetSummarySchema = z.object({
+  id: text,
+  locales: z.array(text),
+  active: z.boolean()
+});
+var statusResultSchema = z.object({
+  enabled: z.boolean(),
+  profile: text,
+  dataHome: text,
+  identityDir: text,
+  presetsDir: text,
+  fileCount: z.number(),
+  totalBytes: z.number(),
+  maxBytes: z.number(),
+  interpolate: z.boolean(),
+  replaceScope: text,
+  drop: z.array(text),
+  fallbackToNative: z.boolean(),
+  activePreset: text,
+  activeLocale: text,
+  hasLocalEdit: z.boolean(),
+  locale: text,
+  localeSource: text,
+  files: z.array(fileStatusSchema),
+  presets: z.array(presetSummarySchema)
+});
+var profileResultSchema = z.object({
+  profile: text,
+  identityDir: text,
+  totalBytes: z.number(),
+  files: z.array(fileTextSchema)
+});
+var presetResultSchema = z.object({
+  found: z.boolean(),
+  id: text,
+  requestedLocale: text,
+  resolvedLocale: text,
+  fellBack: z.boolean(),
+  files: z.array(fileTextSchema)
+});
+var writeResultSchema = z.object({
+  ok: z.boolean(),
+  error: optionalText,
+  resolvedLocale: optionalText,
+  fellBack: z.boolean().optional(),
+  files: z.array(text).optional()
+});
+var declare = (name2, schema) => ({ name: name2, schema, create: () => schema });
+var declaredSchemas = [
+  ...descriptors.flatMap((descriptor) => descriptor.parameters.map((parameter) => declare(`${descriptor.method}${parameter.name}`, parameter.codec.schema))),
+  declare("statusResult", statusResultSchema),
+  declare("profileResult", profileResultSchema),
+  declare("writeResult", writeResultSchema),
+  declare("presetResult", presetResultSchema)
+];
+var model = {
+  services: [
+    {
+      key: NAMESPACE,
+      exportName: NAMESPACE,
+      description: "Identity files: the profile identity, its built-in/edited presets, and the replacement switch",
+      summary: "avantf-identity identity files",
+      tags: [],
+      members: [],
+      types: []
+    }
+  ],
+  // Empty on purpose, but declared: the client mount reads every field of the model.
+  events: [],
+  objects: []
+};
+var hostContribution = {
+  package: PACKAGE,
+  face: "host",
+  schemas: declaredSchemas,
+  model,
+  invocations: descriptors
+};
+
+// lib/gateway.js
+var __runInitializers = function(thisArg, initializers, value) {
+  var useValue = arguments.length > 2;
+  for (var i = 0; i < initializers.length; i++) {
+    value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+  }
+  return useValue ? value : void 0;
+};
+var __esDecorate = function(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+  function accept(f) {
+    if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected");
+    return f;
+  }
+  var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+  var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+  var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+  var _, done = false;
+  for (var i = decorators.length - 1; i >= 0; i--) {
+    var context = {};
+    for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+    for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+    context.addInitializer = function(f) {
+      if (done) throw new TypeError("Cannot add initializers after decoration has completed");
+      extraInitializers.push(accept(f || null));
+    };
+    var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+    if (kind === "accessor") {
+      if (result === void 0) continue;
+      if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+      if (_ = accept(result.get)) descriptor.get = _;
+      if (_ = accept(result.set)) descriptor.set = _;
+      if (_ = accept(result.init)) initializers.unshift(_);
+    } else if (_ = accept(result)) {
+      if (kind === "field") initializers.unshift(_);
+      else descriptor[key] = _;
+    }
+  }
+  if (target) Object.defineProperty(target, contextIn.name, descriptor);
+  done = true;
+};
+var ENTRY_ID = "avantf-identity";
+var LOCALE_NAMESPACE = "locale";
+var LOCALE_PREFERENCE_FIELD = "preference";
+var IdentityGateway = (() => {
+  let _classSuper = TypertRemoteService;
+  let _instanceExtraInitializers = [];
+  let _status_decorators;
+  let _listPresets_decorators;
+  let _readProfile_decorators;
+  let _writeProfileFile_decorators;
+  let _ensureProfile_decorators;
+  let _applyPreset_decorators;
+  let _resetToPreset_decorators;
+  let _saveAsPreset_decorators;
+  let _readPreset_decorators;
+  let _writePresetFile_decorators;
+  let _deletePreset_decorators;
+  return class IdentityGateway extends _classSuper {
+    static {
+      const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+      _status_decorators = [Remote("status")];
+      _listPresets_decorators = [Remote("listPresets")];
+      _readProfile_decorators = [Remote("readProfile")];
+      _writeProfileFile_decorators = [Remote("writeProfileFile")];
+      _ensureProfile_decorators = [Remote("ensureProfile")];
+      _applyPreset_decorators = [Remote("applyPreset")];
+      _resetToPreset_decorators = [Remote("resetToPreset")];
+      _saveAsPreset_decorators = [Remote("saveAsPreset")];
+      _readPreset_decorators = [Remote("readPreset")];
+      _writePresetFile_decorators = [Remote("writePresetFile")];
+      _deletePreset_decorators = [Remote("deletePreset")];
+      __esDecorate(this, null, _status_decorators, { kind: "method", name: "status", static: false, private: false, access: { has: (obj) => "status" in obj, get: (obj) => obj.status }, metadata: _metadata }, null, _instanceExtraInitializers);
+      __esDecorate(this, null, _listPresets_decorators, { kind: "method", name: "listPresets", static: false, private: false, access: { has: (obj) => "listPresets" in obj, get: (obj) => obj.listPresets }, metadata: _metadata }, null, _instanceExtraInitializers);
+      __esDecorate(this, null, _readProfile_decorators, { kind: "method", name: "readProfile", static: false, private: false, access: { has: (obj) => "readProfile" in obj, get: (obj) => obj.readProfile }, metadata: _metadata }, null, _instanceExtraInitializers);
+      __esDecorate(this, null, _writeProfileFile_decorators, { kind: "method", name: "writeProfileFile", static: false, private: false, access: { has: (obj) => "writeProfileFile" in obj, get: (obj) => obj.writeProfileFile }, metadata: _metadata }, null, _instanceExtraInitializers);
+      __esDecorate(this, null, _ensureProfile_decorators, { kind: "method", name: "ensureProfile", static: false, private: false, access: { has: (obj) => "ensureProfile" in obj, get: (obj) => obj.ensureProfile }, metadata: _metadata }, null, _instanceExtraInitializers);
+      __esDecorate(this, null, _applyPreset_decorators, { kind: "method", name: "applyPreset", static: false, private: false, access: { has: (obj) => "applyPreset" in obj, get: (obj) => obj.applyPreset }, metadata: _metadata }, null, _instanceExtraInitializers);
+      __esDecorate(this, null, _resetToPreset_decorators, { kind: "method", name: "resetToPreset", static: false, private: false, access: { has: (obj) => "resetToPreset" in obj, get: (obj) => obj.resetToPreset }, metadata: _metadata }, null, _instanceExtraInitializers);
+      __esDecorate(this, null, _saveAsPreset_decorators, { kind: "method", name: "saveAsPreset", static: false, private: false, access: { has: (obj) => "saveAsPreset" in obj, get: (obj) => obj.saveAsPreset }, metadata: _metadata }, null, _instanceExtraInitializers);
+      __esDecorate(this, null, _readPreset_decorators, { kind: "method", name: "readPreset", static: false, private: false, access: { has: (obj) => "readPreset" in obj, get: (obj) => obj.readPreset }, metadata: _metadata }, null, _instanceExtraInitializers);
+      __esDecorate(this, null, _writePresetFile_decorators, { kind: "method", name: "writePresetFile", static: false, private: false, access: { has: (obj) => "writePresetFile" in obj, get: (obj) => obj.writePresetFile }, metadata: _metadata }, null, _instanceExtraInitializers);
+      __esDecorate(this, null, _deletePreset_decorators, { kind: "method", name: "deletePreset", static: false, private: false, access: { has: (obj) => "deletePreset" in obj, get: (obj) => obj.deletePreset }, metadata: _metadata }, null, _instanceExtraInitializers);
+      if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+    }
+    state = __runInitializers(this, _instanceExtraInitializers);
+    settings;
+    log;
+    constructor(ctx, state, settings, log) {
+      super(ctx, NAMESPACE);
+      this.state = state;
+      this.settings = settings;
+      this.log = log;
+    }
+    /** The settings page's ONE entry point: the header, the three file slots, and the preset library. */
+    status(args) {
+      return this.state.status(this.settings(), this.localeInfo(args.locale));
+    }
+    /** The preset library, with the active one marked. */
+    listPresets() {
+      return { presets: this.state.presetSummaries(this.settings().activePreset) };
+    }
+    /** The three files of the effective identity, with their text. */
+    readProfile() {
+      return this.state.readProfile();
+    }
+    /** Write one effective-identity file. The next assembly reads it; nothing else is touched. */
+    writeProfileFile(args) {
+      const result = this.state.writeProfileFile(args.name, args.text);
+      if (result.ok)
+        this.log.info(`wrote ${args.name}.md (${String(Buffer.byteLength(args.text, "utf8"))} bytes); the next assembly reads it`);
+      return result;
+    }
+    /**
+     * Materialize an identity for the current profile when it has none: the switch's FIRST enable calls
+     * this, so turning the identity on produces something to edit instead of three empty editors over a
+     * prompt that still says `harness:identity` (the first run releases the preset LIBRARY only).
+     *
+     * A no-op once any file carries text — it never overwrites what the user wrote — and a reported error,
+     * never a silent nothing, when the library is empty.
+     */
+    async ensureProfile(args) {
+      const { locale } = this.localeInfo(args.locale);
+      const seed = this.state.ensureProfile(locale);
+      if (seed.error !== void 0)
+        return { ok: false, error: seed.error };
+      if (seed.seeded) {
+        this.log.info(`seeded the effective identity for profile ${this.state.profile} from preset ${String(seed.preset ?? "")} (${String(seed.resolvedLocale ?? locale)})`);
+        await this.remember({ activePreset: seed.preset ?? "", activeLocale: seed.resolvedLocale ?? locale });
+      }
+      return {
+        ok: true,
+        ...seed.resolvedLocale === void 0 ? {} : { resolvedLocale: seed.resolvedLocale },
+        ...seed.fellBack === void 0 ? {} : { fellBack: seed.fellBack },
+        ...seed.written.length === 0 ? {} : { files: seed.written }
+      };
+    }
+    /**
+     * Switch to a preset, then record which preset/locale is in force.
+     *
+     * The identity being LEFT is named to the state, which files its current content away under that id
+     * before the write — that is what makes coming back to it restore the user's own text instead of the
+     * library's. Leaving an identity that no preset owns is refused (see `IdentityState.applyPreset`).
+     */
+    async applyPreset(args) {
+      const { locale } = this.localeInfo(args.locale);
+      const result = this.state.applyPreset(args.id, locale, this.settings().activePreset);
+      if (result.ok) {
+        this.log.info(result.restoredEdit === true ? `switched to ${args.id}: restored this profile's own version` : `applied preset ${args.id} (${String(result.resolvedLocale ?? locale)}${result.fellBack === true ? ", fell back to en" : ""})`);
+        await this.remember({ activePreset: args.id, activeLocale: result.resolvedLocale ?? this.settings().activeLocale ?? locale });
+      }
+      return result;
+    }
+    /**
+     * Drop this profile's own version of `id` and put the library preset's text back in force — the way
+     * out of a customized identity. Destructive by intent; the page confirms it.
+     */
+    async resetToPreset(args) {
+      const { locale } = this.localeInfo(args.locale);
+      const result = this.state.resetToPreset(args.id, locale);
+      if (result.ok)
+        this.log.info(`restored the preset text of ${args.id} (dropped this profile's version: ${String(result.dropped === true)})`);
+      return result;
+    }
+    /** Save the effective identity as a new preset under the locale the caller is showing. */
+    saveAsPreset(args) {
+      const { locale } = this.localeInfo(args.locale);
+      return this.state.saveAsPreset(args.id, locale);
+    }
+    /** Read one preset (English fallback when the requested locale has no directory). */
+    readPreset(args) {
+      const { locale } = this.localeInfo(args.locale);
+      return this.state.readPreset(args.id, locale);
+    }
+    /** Write one preset file. Never touches the effective identity (the page says so out loud). */
+    writePresetFile(args) {
+      const { locale } = this.localeInfo(args.locale);
+      return this.state.writePresetFile(args.id, args.name, args.text, locale);
+    }
+    /**
+     * Delete one preset from the library (and, with it, this profile's version of it).
+     *
+     * Deleting the identity that is IN FORCE also forgets it: the effective files stay where they are, but
+     * their id is gone, so the state must treat them as unowned from here on — otherwise the next switch
+     * would file them away under a name the dropdown no longer shows.
+     */
+    async deletePreset(args) {
+      const wasActive = this.settings().activePreset === args.id;
+      const result = this.state.deletePreset(args.id);
+      if (result.ok) {
+        this.log.info(`deleted preset ${args.id}`);
+        if (wasActive)
+          await this.remember({ activePreset: "", activeLocale: "" });
+      }
+      return result;
+    }
+    /**
+     * Record which preset/locale is in force, so a later language change can offer "apply it again in
+     * `<new language>`" WITHOUT ever rewriting the user's files. Best-effort: a host whose settings
+     * service is absent or read-only mounts and works, it just cannot remember this.
+     */
+    async remember(patch) {
+      try {
+        const settings = this.ctx.get("settings");
+        if (settings === void 0 || typeof settings.update !== "function")
+          return;
+        await settings.update(ENTRY_ID, patch);
+      } catch (error) {
+        this.log.warn(`could not record the active preset in the profile config (${reasonOf3(error)}); the identity itself is applied`);
+      }
+    }
+    /**
+     * The language to apply in: the caller's own (UI-triggered applies always carry it), else the host's
+     * explicit `locale` preference, else English.
+     *
+     * The browser's `locale` service exists only on the CLIENT half, so a headless caller reads the same
+     * preference through the settings projection — the field `dsh-client-locale` writes only when a user
+     * has explicitly chosen a language, which is exactly the "no browser to delegate to" case.
+     */
+    localeInfo(requested) {
+      if (typeof requested === "string" && isValidLocale(requested))
+        return { locale: requested, source: "client" };
+      const host = this.hostLocale();
+      if (host !== void 0)
+        return { locale: host, source: "host" };
+      return { locale: FALLBACK_LOCALE, source: "fallback" };
+    }
+    hostLocale() {
+      try {
+        const settings = this.ctx.get("settings");
+        const descriptors2 = settings?.describe?.();
+        if (!Array.isArray(descriptors2))
+          return void 0;
+        for (const descriptor of descriptors2) {
+          const record = descriptor;
+          if (record?.ns !== LOCALE_NAMESPACE)
+            continue;
+          const value = record.value;
+          const preference = value?.[LOCALE_PREFERENCE_FIELD];
+          if (typeof preference === "string" && isValidLocale(preference))
+            return preference;
+        }
+      } catch {
+      }
+      return void 0;
+    }
+  };
+})();
+function reasonOf3(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// lib/log.js
+var LOG_PREFIX = "[avantf-identity]";
+function createLogger(host, sink = (line) => {
+  console.error(line);
+}) {
+  const emit = (level, message) => {
+    sink(`${LOG_PREFIX} ${level.toUpperCase()} ${message}`);
+    try {
+      host?.[level](`${LOG_PREFIX} ${message}`);
+    } catch {
+    }
+  };
+  return {
+    info: (message) => {
+      emit("info", message);
+    },
+    warn: (message) => {
+      emit("warn", message);
+    },
+    error: (message) => {
+      emit("error", message);
+    }
+  };
+}
+
+// lib/session-freeze.js
+var SessionFreeze = class {
+  held = /* @__PURE__ */ new WeakMap();
+  /**
+   * The frozen text for `key`, calling `read` exactly once per key.
+   *
+   * @param key - the session object, or `undefined` to read live on every call.
+   * @param read - reads the current text; called only when no value is held yet.
+   * @returns the text this session is stuck with.
+   */
+  text(key, read) {
+    if (key === void 0)
+      return read();
+    const existing = this.held.get(key);
+    if (existing !== void 0)
+      return existing;
+    const value = read();
+    this.held.set(key, value);
+    return value;
+  }
+};
+
+// lib/state.js
+import { existsSync as existsSync2 } from "node:fs";
+
+// lib/documents.js
+import { mkdirSync as mkdirSync2, readFileSync as readFileSync2, statSync } from "node:fs";
+import { dirname, join as join3 } from "node:path";
+function fileNameOf(name2) {
+  return `${name2}.md`;
+}
+function rulesHeading(body) {
+  return /[\u3400-\u4DBF\u4E00-\u9FFF\uF900-\uFAFF]/u.test(body) ? "**规则**" : "**Rules**";
+}
+var IdentityDocuments = class {
+  dir;
+  options;
+  cache = /* @__PURE__ */ new Map();
+  constructor(dir, options = { maxBytes: () => 0 }) {
+    this.dir = dir;
+    this.options = options;
+  }
+  /** The directory the three files live in. */
+  get directory() {
+    return this.dir;
+  }
+  /** One file's path. */
+  pathOf(name2) {
+    return join3(this.dir, fileNameOf(name2));
+  }
+  /**
+   * Read one file, or `''` when it is absent or unreadable.
+   *
+   * Cached on `(mtimeMs, size)`: the two together are what a text editor changes, and the stat is an
+   * order of magnitude cheaper than the read for the tens-of-KB files this holds.
+   */
+  read(name2) {
+    const path = this.pathOf(name2);
+    try {
+      const stat = statSync(path);
+      const cached = this.cache.get(name2);
+      if (cached !== void 0 && cached.mtimeMs === stat.mtimeMs && cached.size === stat.size)
+        return cached.text;
+      const text2 = readFileSync2(path, "utf8");
+      this.cache.set(name2, { mtimeMs: stat.mtimeMs, size: stat.size, text: text2 });
+      return text2;
+    } catch {
+      this.cache.delete(name2);
+      return "";
+    }
+  }
+  /** Every file's text, in render order. */
+  readAll() {
+    return IDENTITY_FILES.map((name2) => {
+      const text2 = this.read(name2);
+      return { name: name2, file: fileNameOf(name2), text: text2, present: text2.trim() !== "", bytes: Buffer.byteLength(text2, "utf8") };
+    });
+  }
+  /** Every file's presence and size, without rendering. */
+  status() {
+    return IDENTITY_FILES.map((name2) => {
+      const text2 = this.read(name2);
+      return {
+        name: name2,
+        file: fileNameOf(name2),
+        path: this.pathOf(name2),
+        present: text2.trim() !== "",
+        bytes: Buffer.byteLength(text2, "utf8")
+      };
+    });
+  }
+  /**
+   * The prompt text: the non-empty bodies joined by one blank line, the rules part under its own
+   * heading (see {@link RULES_HEADING}), truncated to `maxBytes` (when it is positive) with a visible
+   * notice appended and a warning naming the files that overflowed.
+   */
+  render() {
+    const parts = IDENTITY_FILES.map((name2) => ({ name: name2, body: this.read(name2).trim() })).filter((part) => part.body !== "");
+    if (parts.length === 0)
+      return "";
+    const text2 = parts.map((part) => part.name === "RULES" ? `${rulesHeading(part.body)}
+
+${part.body}` : part.body).join("\n\n");
+    const maxBytes = this.options.maxBytes();
+    if (!Number.isFinite(maxBytes) || maxBytes <= 0)
+      return text2;
+    if (Buffer.byteLength(text2, "utf8") <= maxBytes)
+      return text2;
+    const truncated = Buffer.from(text2, "utf8").subarray(0, maxBytes).toString("utf8").replace(/\uFFFD$/u, "");
+    this.options.logger?.warn(`identity files exceed maxBytes=${String(maxBytes)}; truncated (files: ${this.status().filter((s) => s.present).map((s) => s.file).join(", ")})`);
+    return `${truncated}
+
+[identity files truncated at ${String(maxBytes)} bytes; the full text is in ${this.dir}]`;
+  }
+  /** Total rendered-model bytes across the three files, without truncation. */
+  bytes() {
+    return this.status().reduce((total, file) => total + file.bytes, 0);
+  }
+  /** Drop the read cache, so the next read comes from disk. Called after every write. */
+  invalidate() {
+    this.cache.clear();
+  }
+  /**
+   * Write one file atomically, so an assembly reading concurrently sees either the old text or the new
+   * one, never a half-written file. The write itself is `writeFileAtomically`'s (shared with the preset
+   * writers); the cache is dropped here, in a `finally`, so a failed write cannot leave it serving text
+   * that is no longer on disk.
+   */
+  write(name2, text2) {
+    if (!IDENTITY_FILES.includes(name2))
+      throw new Error(`unknown identity file: ${String(name2)}`);
+    mkdirSync2(this.dir, { recursive: true });
+    try {
+      writeFileAtomically(this.pathOf(name2), text2);
+    } finally {
+      this.invalidate();
+    }
+  }
+  /** The identity directory itself; exported so a caller need not re-derive it. */
+  get root() {
+    return dirname(this.dir);
+  }
+};
+
+// lib/state.js
+var IdentityState = class {
+  options;
+  dataHomeValue;
+  documentsCache;
+  constructor(options) {
+    this.options = options;
+    this.dataHomeValue = options.dataHome;
+  }
+  /** The data home currently in force. */
+  get dataHome() {
+    return this.dataHomeValue;
+  }
+  /** `<data home>/identity`. */
+  get root() {
+    return identityRoot(this.dataHomeValue);
+  }
+  /** The profile whose identity is effective (the profile context's name, or the configured one). */
+  get profile() {
+    const profile = this.options.profile().trim();
+    return profile === "" ? "default" : profile;
+  }
+  /** `profiles/<profile>/` — the ONE source of the effective identity. */
+  get profileDir() {
+    return profileDir(this.root, this.profile);
+  }
+  /** `presets/`. */
+  get presetsDir() {
+    return presetsRoot(this.root);
+  }
+  /** The three files of the effective identity (recreated when the data home or profile moves). */
+  get documents() {
+    const dir = this.profileDir;
+    if (this.documentsCache?.dir !== dir) {
+      this.documentsCache = {
+        dir,
+        documents: new IdentityDocuments(dir, {
+          ...this.options.logger === void 0 ? {} : { logger: this.options.logger },
+          maxBytes: this.options.maxBytes
+        })
+      };
+    }
+    return this.documentsCache.documents;
+  }
+  /** Point the state at the base's answer. A different root drops the cached reader. */
+  setDataHome(next) {
+    if (next === this.dataHomeValue)
+      return;
+    this.dataHomeValue = next;
+    this.documentsCache = void 0;
+  }
+  /**
+   * The section text: the rendered files when the switch is on, `''` when it is off. `''` is what
+   * makes "off" byte-identical to native — the empty section is dropped by `renderPrompt`, and the
+   * waterfall removes it as well.
+   */
+  sectionText(enabled) {
+    if (!enabled)
+      return "";
+    try {
+      return this.documents.render();
+    } catch (error) {
+      this.options.logger?.warn(`rendering the identity files failed (${reasonOf4(error)}); falling back to the native prompt`);
+      return "";
+    }
+  }
+  /** Release the built-in presets (missing-only). Never throws. */
+  provision(assetsDir) {
+    const source = assetsDir ?? this.options.assetsDir ?? resolveAssetsDir();
+    if (source === void 0 || !existsSync2(source)) {
+      this.options.logger?.warn("the built-in preset assets are missing from this build; no preset was released");
+      return { copied: [], skipped: [] };
+    }
+    return materializePresets({
+      assetsDir: source,
+      root: this.root,
+      version: this.options.version,
+      ...this.options.logger === void 0 ? {} : { logger: this.options.logger }
+    });
+  }
+  /** Every preset on disk, marking the one this profile is currently using. */
+  presetSummaries(activePreset) {
+    return listPresets(this.root).map((preset) => ({
+      id: preset.id,
+      locales: preset.locales,
+      active: preset.id === activePreset
+    }));
+  }
+  /** The effective identity's three files, with their text. */
+  readProfile() {
+    const files = this.documents.readAll();
+    return {
+      profile: this.profile,
+      identityDir: this.profileDir,
+      totalBytes: files.reduce((total, file) => total + file.bytes, 0),
+      files
+    };
+  }
+  /** Write one effective-identity file. Answers an error string instead of throwing. */
+  writeProfileFile(name2, text2) {
+    const file = identityNameOfLoose(name2);
+    if (file === void 0)
+      return { ok: false, error: `unknown identity file: ${name2}` };
+    try {
+      this.documents.write(file, text2);
+      return { ok: true };
+    } catch (error) {
+      return { ok: false, error: reasonOf4(error) };
+    }
+  }
+  /** Read one preset with locale fallback; `undefined` when the preset or its English copy is absent. */
+  readPreset(id, locale) {
+    const read = readPreset(this.root, id, locale);
+    if (read === void 0) {
+      return { found: false, id, requestedLocale: locale, resolvedLocale: FALLBACK_LOCALE, fellBack: false, files: [] };
+    }
+    return { found: true, ...read };
+  }
+  /** Write one preset file in one locale. */
+  writePresetFile(id, name2, text2, locale) {
+    const file = identityNameOfLoose(name2);
+    if (file === void 0)
+      return { ok: false, error: `unknown identity file: ${name2}` };
+    if (!isValidPresetId(id))
+      return { ok: false, error: `invalid preset id: ${id}` };
+    try {
+      writePresetFile(this.root, id, locale, file, text2);
+      return { ok: true };
+    } catch (error) {
+      return { ok: false, error: reasonOf4(error) };
+    }
+  }
+  /**
+   * Switch the effective identity to `id`.
+   *
+   * `previousId` is the identity being LEFT (the caller's live `activePreset`): its current content is
+   * filed away under that id FIRST, so coming back to it later restores what the user wrote instead of
+   * the library's factory text. The incoming identity is then taken from this profile's own version when
+   * one exists, and from the library preset otherwise.
+   *
+   * `previousId === ''` with a non-empty effective identity means the user hand-wrote content that no
+   * identity owns: switching away would leave it nowhere to come back to, so it is REFUSED with an
+   * explanation rather than silently destroyed.
+   */
+  applyPreset(id, locale, previousId = "") {
+    try {
+      const effective = this.documents.readAll();
+      if (previousId === "" && effective.some((file) => file.present)) {
+        return { ok: false, error: 'this identity has no preset id, so switching away would destroy it; use "save as preset" first' };
+      }
+      if (previousId !== "")
+        snapshotProfileEdit({ root: this.root, profile: this.profile, id: previousId, files: effective });
+      const restored = applyProfileEditToProfile({ root: this.root, profile: this.profile, id });
+      if (restored !== void 0) {
+        this.documents.invalidate();
+        return { ok: true, files: restored.written, restoredEdit: true };
+      }
+      return this.fromLibraryPreset(id, locale);
+    } catch (error) {
+      return { ok: false, error: reasonOf4(error) };
+    }
+  }
+  /** Discard this profile's own version of `id` and put the library preset's text back in force. */
+  resetToPreset(id, locale) {
+    try {
+      const dropped = dropProfileEdit({ root: this.root, profile: this.profile, id });
+      const applied = this.fromLibraryPreset(id, locale);
+      return applied.ok ? { ...applied, dropped } : applied;
+    } catch (error) {
+      return { ok: false, error: reasonOf4(error) };
+    }
+  }
+  /**
+   * Write a library preset's text into the effective identity and shape the answer both callers return.
+   *
+   * Always invalidates the reader: the write went behind its back, and a stale cache would keep serving
+   * the old identity until the mtime happened to move.
+   */
+  fromLibraryPreset(id, locale) {
+    const applied = applyPresetToProfile({ root: this.root, profile: this.profile, id, locale });
+    if (applied === void 0)
+      return { ok: false, error: `preset not found or has no ${FALLBACK_LOCALE} copy: ${id}` };
+    this.documents.invalidate();
+    return { ok: true, resolvedLocale: applied.resolvedLocale, fellBack: applied.fellBack, files: applied.written };
+  }
+  /**
+   * Whether the effective identity differs from what preset `id` ships in `locale`.
+   * @param effectiveFiles - the effective files already read, when the caller has them.
+   */
+  hasLocalEdit(id, locale, effectiveFiles) {
+    return profileDiffersFromPreset({ root: this.root, profile: this.profile, id, locale, ...effectiveFiles === void 0 ? {} : { effectiveFiles } });
+  }
+  /**
+   * Materialize an effective identity for THIS profile when it has none — what the switch's first
+   * enable asks the host for (see `presets.seedProfileIfEmpty`). Never overwrites the user's files.
+   */
+  ensureProfile(locale) {
+    try {
+      const seed = seedProfileIfEmpty({ root: this.root, profile: this.profile, locale });
+      this.documents.invalidate();
+      return seed;
+    } catch (error) {
+      return { seeded: false, written: [], error: reasonOf4(error) };
+    }
+  }
+  /** Save the effective identity as a new preset. */
+  saveAsPreset(id, locale) {
+    if (!isValidPresetId(id))
+      return { ok: false, error: `invalid preset id: ${id}` };
+    try {
+      const saved = saveProfileAsPreset({ root: this.root, profile: this.profile, id, locale });
+      if (saved === void 0)
+        return { ok: false, error: `preset already exists: ${id}` };
+      if (saved.written.length === 0)
+        return { ok: false, error: "the effective identity is empty; nothing to save" };
+      return { ok: true, files: saved.written };
+    } catch (error) {
+      return { ok: false, error: reasonOf4(error) };
+    }
+  }
+  /**
+   * Delete one preset from the library.
+   *
+   * This profile's own version of it goes too: once the identity is out of the dropdown, that version
+   * is unreachable — keeping it would only leave a shadow that a future release could resurrect.
+   */
+  deletePreset(id) {
+    try {
+      if (!deletePreset(this.root, id))
+        return { ok: false, error: `preset not found: ${id}` };
+      dropProfileEdit({ root: this.root, profile: this.profile, id });
+      return { ok: true };
+    } catch (error) {
+      return { ok: false, error: reasonOf4(error) };
+    }
+  }
+  /**
+   * The header's one call: everything the settings page renders above the editors.
+   *
+   * The three effective files are read ONCE here and reused for both the status rows and the
+   * "you have your own version" comparison — reading them a second time was pure work, and this call
+   * also walks the preset library (see `presetSummaries`).
+   */
+  status(settings, locale) {
+    const entries = this.documents.readAll();
+    const files = entries.map((file) => ({
+      name: file.name,
+      file: file.file,
+      path: this.documents.pathOf(file.name),
+      present: file.present,
+      bytes: file.bytes
+    }));
+    const present = files.filter((file) => file.present);
+    return {
+      enabled: settings.enabled,
+      profile: this.profile,
+      dataHome: this.dataHomeValue,
+      identityDir: this.profileDir,
+      presetsDir: this.presetsDir,
+      fileCount: present.length,
+      totalBytes: files.reduce((total, file) => total + file.bytes, 0),
+      maxBytes: settings.maxBytes,
+      interpolate: settings.interpolate,
+      replaceScope: settings.replaceScope,
+      drop: settings.drop,
+      fallbackToNative: !settings.enabled || present.length === 0,
+      activePreset: settings.activePreset,
+      activeLocale: settings.activeLocale,
+      // "You have your own version of the identity in force" — what enables 「恢复预设原文」.
+      hasLocalEdit: settings.activePreset !== "" && this.hasLocalEdit(settings.activePreset, locale.locale, entries),
+      locale: locale.locale,
+      localeSource: locale.source,
+      files,
+      presets: this.presetSummaries(settings.activePreset)
+    };
+  }
+  /** The preset locale directory (read-only accessor for diagnostics and tests). */
+  presetDir(id, locale) {
+    return presetLocaleDir(this.root, id, locale);
+  }
+};
+function identityNameOfLoose(name2) {
+  const upper = name2.trim().toUpperCase().replace(/\.MD$/u, "");
+  return IDENTITY_FILES.includes(upper) ? upper : void 0;
+}
+function reasonOf4(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// lib/volatile.js
+function volatileValue(field, fallback) {
+  if (field === void 0)
+    return fallback;
+  const get = field.get;
+  if (typeof get === "function") {
+    try {
+      const value = get.call(field);
+      return value === void 0 ? fallback : value;
+    } catch {
+      return fallback;
+    }
+  }
+  return field;
+}
+
+// lib/index.js
+var name = "avantf-identity";
+var inject = ["systemPrompt"];
+var OWN_SECTION = "avantf:identity";
+var HARNESS_IDENTITY_SECTION = "harness:identity";
+var DEFAULT_DROP = [HARNESS_IDENTITY_SECTION, PERSONA_PREFIX_SECTION];
+var DEFAULT_MAX_BYTES = 65536;
+var Config = z2.object({
+  enabled: z2.boolean().default(false).volatile(),
+  interpolate: z2.boolean().default(false).volatile(),
+  replaceScope: z2.union([z2.const("session"), z2.const("all")]).default("session").volatile(),
+  drop: z2.array(z2.string()).default([...DEFAULT_DROP]).volatile(),
+  maxBytes: z2.natural().default(DEFAULT_MAX_BYTES).volatile(),
+  profile: z2.string().default("").volatile(),
+  dataHome: z2.string().default("").volatile(),
+  activePreset: z2.string().default("").volatile(),
+  activeLocale: z2.string().default("").volatile()
+});
+function isMainAgent(context) {
+  const agent = context.agent;
+  const header = agent?.session?.header;
+  return header?.origin !== "subagent" && (header?.delegationDepth ?? 0) === 0;
+}
+function sessionKeyOf(context) {
+  const agent = context.agent;
+  const session = agent?.session;
+  return session !== null && typeof session === "object" ? session : void 0;
+}
+function profileContextName(ctx) {
+  try {
+    const profileContext = ctx.get("profileContext");
+    const value = profileContext?.name;
+    return typeof value === "string" && value.trim() !== "" ? value.trim() : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function packageVersion() {
+  for (const relative of ["../package.json"]) {
+    try {
+      const parsed = JSON.parse(readFileSync3(new URL(relative, import.meta.url), "utf8"));
+      if (typeof parsed.version === "string" && parsed.version !== "")
+        return parsed.version;
+    } catch {
+    }
+  }
+  return "unknown";
+}
+function reasonOf5(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+async function initialize(options) {
+  const { ctx, state, settings, log } = options;
+  try {
+    const base = await loadBase({ log });
+    if (!stillActive(ctx)) {
+      log.warn("unmounted while preparing the environment; leaving the data home as it was resolved");
+      return;
+    }
+    const resolve = base?.dataHome ?? resolveDataHomeMirror;
+    state.setDataHome(resolve({ configured: settings().dataHome }));
+    log.info(base === void 0 ? `data home resolved by this plugin's own mirror: ${state.dataHome}` : `data home resolved by @avantf/dsh-plugin-base: ${state.dataHome}`);
+    const assetsDir = resolveAssetsDir();
+    if (assetsDir === void 0) {
+      log.warn("the built-in preset assets are missing from this build; no preset was released");
+      return;
+    }
+    const provisioned = state.provision(assetsDir);
+    log.info(`preset library ready at ${state.presetsDir} (released: ${provisioned.copied.length === 0 ? "nothing new" : provisioned.copied.join(", ")})`);
+  } catch (error) {
+    log.warn(`startup initialisation failed (${reasonOf5(error)}); the plugin mounts with the data home it can resolve`);
+  }
+}
+async function apply(ctx, config) {
+  const log = createLogger(ctx.logger);
+  const settings = () => ({
+    enabled: volatileValue(config.enabled, false),
+    interpolate: volatileValue(config.interpolate, false),
+    replaceScope: volatileValue(config.replaceScope, "session"),
+    drop: volatileValue(config.drop, DEFAULT_DROP),
+    maxBytes: volatileValue(config.maxBytes, DEFAULT_MAX_BYTES),
+    profile: volatileValue(config.profile, ""),
+    dataHome: volatileValue(config.dataHome, ""),
+    activePreset: volatileValue(config.activePreset, ""),
+    activeLocale: volatileValue(config.activeLocale, "")
+  });
+  const state = new IdentityState({
+    // The provisional answer, replaced by the base's own rule once it is loaded: the family mirror is
+    // what the base would say with no base present, so nothing is invented in the meantime.
+    dataHome: resolveDataHomeMirror({ configured: settings().dataHome }),
+    profile: () => profileContextName(ctx) ?? settings().profile,
+    maxBytes: () => settings().maxBytes,
+    version: packageVersion(),
+    logger: log
+  });
+  log.info(`mounting: enabled=${String(settings().enabled)} profile=${state.profile} assets=${String(resolveAssetsDir() ?? "MISSING")}`);
+  const freeze = new SessionFreeze();
+  const ownSection = {
+    name: OWN_SECTION,
+    order: ctx.systemPrompt.getSectionOrder("HARNESS_IDENTITY"),
+    interpolate: settings().interpolate,
+    text: (context) => freeze.text(sessionKeyOf(context), () => state.sectionText(settings().enabled))
+  };
+  ctx.effect(() => ctx.systemPrompt.section(ownSection), "avantf-identity:section");
+  ctx.on("system-prompt/assemble", async (_assembly, context, next) => {
+    const out = await next();
+    const snapshot = settings();
+    const own = out.sections.find((section) => section.name === OWN_SECTION);
+    const applicable = own !== void 0 && own.text.length > 0 && (snapshot.replaceScope === "all" || isMainAgent(context));
+    const drop = new Set(applicable ? snapshot.drop : [OWN_SECTION]);
+    if (drop.size === 0)
+      return out;
+    const sections = out.sections.filter((section) => !drop.has(section.name));
+    return sections.length === out.sections.length ? out : { ...out, sections };
+  });
+  new IdentityGateway(ctx, state, settings, log);
+  const typert = ctx.get("typert");
+  if (typert === void 0 || typeof typert.register !== "function") {
+    log.warn("no typert registry mounted; the settings page will report it instead of reading the identity files");
+  } else {
+    try {
+      typert.register(hostContribution);
+      log.info(`typert host face registered (namespace avantfIdentity, ${String(hostContribution.invocations?.length ?? 0)} invocations)`);
+    } catch (error) {
+      log.error(`typert host face FAILED to register: the settings page will report it; the prompt mechanism mounts anyway — ${reasonOf5(error)}`);
+    }
+  }
+  ctx.inject(["settings"], (child) => {
+    child.effect(() => {
+      const forms = child.get("settings");
+      if (forms === void 0 || typeof forms.configure !== "function")
+        return () => void 0;
+      return forms.configure({ auto: false }, ctx.fiber) ?? (() => void 0);
+    }, "avantf-identity:no-auto-form");
+  });
+  await initialize({ ctx, state, settings, log });
+}
+export {
+  Config,
+  DEFAULT_DROP,
+  DEFAULT_MAX_BYTES,
+  HARNESS_IDENTITY_SECTION,
+  OWN_SECTION,
+  apply,
+  inject,
+  isMainAgent,
+  name,
+  sessionKeyOf
+};