@yaawn/workflow 0.4.0 → 0.5.0

package/dist/config/config.js

@@ -0,0 +1,118 @@
+import path from "node:path";
+import { createSettingsDir, DEFAULT_AGENT, isAgent, PROJECT_DIR, readAgentSetting, writeAgentSetting, } from "./agents.js";
+import { UnknownAgentError } from "./errors.js";
+import { contain } from "./paths.js";
+import { decodeSettings, SETTINGS_FILE, settingsError, validateSettings } from "./settings.js";
+import { readJsonDocument, sortedKeys } from "./strict-json.js";
+import { decodeInstallTasks, INSTALL_TASKS_FILE, isSeedOnly, validateInstallTasks } from "./tasks.js";
+import { decodeWizard, singleSelectSection, validateWizard, WIZARD_FILE } from "./wizard.js";
+/** The config directory inside the package root. */
+export const CONFIG_DIR = "config";
+/** A file the wizard appends to: seeded by a sync target and owned by the user afterwards. */
+export class OutputFile {
+    key;
+    name;
+    target;
+    constructor(key, name, target) {
+        this.key = key;
+        this.name = name;
+        this.target = target;
+    }
+    /** The seed copy of the file inside the package. */
+    sourcePath(packageRoot) {
+        return contain(packageRoot, this.target.source, this.name);
+    }
+    /** The file inside the project. */
+    destinationPath(projectRoot) {
+        return contain(projectRoot, this.target.target, this.name);
+    }
+    /** The project-relative, slash-separated path. */
+    displayPath() {
+        return path.posix.join(this.target.target, this.name);
+    }
+}
+/** The three validated config files. */
+export class Config {
+    settings;
+    wizard;
+    tasks;
+    constructor(settings, wizard, tasks) {
+        this.settings = settings;
+        this.wizard = wizard;
+        this.tasks = tasks;
+    }
+    /** Looks up the output file registered under key. */
+    outputFile(key) {
+        if (!Object.hasOwn(this.settings.outputFileNames, key)) {
+            return undefined;
+        }
+        const name = this.settings.outputFileNames[key] ?? "";
+        const target = this.tasks.syncTargets.find((candidate) => isSeedOnly(candidate, name));
+        return target === undefined ? undefined : new OutputFile(key, name, target);
+    }
+    /** The output file names; the sync never deletes them even when a removeFirst pattern matches. */
+    userOwnedFiles() {
+        return sortedKeys(this.settings.outputFileNames).map((key) => this.settings.outputFileNames[key] ?? key);
+    }
+    /** The settings file inside projectRoot; throws PathEscapeError when it would escape. */
+    agentSettingsPath(projectRoot) {
+        return contain(projectRoot, PROJECT_DIR, this.settings.settingsFileName);
+    }
+    /** The agent saved in the project's settings file; undefined whenever it cannot be read safely. */
+    previousAgent(projectRoot) {
+        try {
+            return readAgentSetting(this.agentSettingsPath(projectRoot));
+        }
+        catch {
+            return undefined;
+        }
+    }
+    /** requested when it is an allowed agent, else the project's previous choice, else the default agent. */
+    resolveAgent(projectRoot, requested) {
+        if (isAgent(requested)) {
+            return requested;
+        }
+        return this.previousAgent(projectRoot) ?? this.agentDefault();
+    }
+    /**
+     * Writes agent to the project's settings file, creating .yaawn/ when
+     * missing. The path is contained before and after the directory is
+     * created, so a symlink planted on the way cannot redirect the write.
+     */
+    saveAgent(projectRoot, agent) {
+        if (!isAgent(agent)) {
+            throw new UnknownAgentError(agent);
+        }
+        createSettingsDir(this.agentSettingsPath(projectRoot));
+        writeAgentSetting(this.agentSettingsPath(projectRoot), agent);
+    }
+    /** The default of the single-select section, or DEFAULT_AGENT without one. */
+    agentDefault() {
+        const fallback = singleSelectSection(this.wizard)?.default;
+        return isAgent(fallback) ? fallback : DEFAULT_AGENT;
+    }
+}
+/** Reads and validates settings.json, wizard.json and install-tasks.json from the config directory of packageRoot. */
+export function loadConfig(packageRoot) {
+    const dir = contain(packageRoot, CONFIG_DIR);
+    const settings = decodeSettings(readJsonDocument(contain(dir, SETTINGS_FILE), SETTINGS_FILE));
+    const wizard = decodeWizard(readJsonDocument(contain(dir, WIZARD_FILE), WIZARD_FILE));
+    const tasks = decodeInstallTasks(readJsonDocument(contain(dir, INSTALL_TASKS_FILE), INSTALL_TASKS_FILE));
+    return createConfig(settings, wizard, tasks);
+}
+/** Validates the three config parts, including the references between them. */
+export function createConfig(settingsDocument, wizard, tasks) {
+    const settings = validateSettings(settingsDocument);
+    validateWizard(wizard, settings);
+    validateInstallTasks(tasks, settings.filePrefix);
+    const config = new Config(settings, wizard, tasks);
+    validateOutputFiles(config);
+    return config;
+}
+/** Requires every output file to be seed-only in a sync target, so it has a known location and is never deleted. */
+function validateOutputFiles(config) {
+    const unseeded = sortedKeys(config.settings.outputFileNames).find((key) => config.outputFile(key) === undefined);
+    if (unseeded !== undefined) {
+        throw settingsError(`outputFileNames.${unseeded}`, `must be listed in a syncTargets seedOnly array of ${INSTALL_TASKS_FILE}`);
+    }
+}

package/dist/config/errors.js

@@ -0,0 +1,45 @@
+/** A config value that breaks the schema, named by file and field path. */
+export class ValidationError extends Error {
+    file;
+    field;
+    problem;
+    name = "ValidationError";
+    constructor(file, field, problem) {
+        super(`${file}: ${field} ${problem}`);
+        this.file = file;
+        this.field = field;
+        this.problem = problem;
+    }
+}
+/** A config file that could not be read. */
+export class LoadError extends Error {
+    file;
+    name = "LoadError";
+    constructor(file, cause) {
+        super(`${file}: ${describeCause(cause)}`, { cause });
+        this.file = file;
+    }
+}
+/** A path that resolves outside its root, directly or through a symlink. */
+export class PathEscapeError extends Error {
+    path;
+    root;
+    name = "PathEscapeError";
+    constructor(path, root) {
+        super(`path ${path} escapes ${root}`);
+        this.path = path;
+        this.root = root;
+    }
+}
+/** An agent outside the allow-list of coding agents. */
+export class UnknownAgentError extends Error {
+    agent;
+    name = "UnknownAgentError";
+    constructor(agent) {
+        super("unknown coding agent");
+        this.agent = agent;
+    }
+}
+function describeCause(cause) {
+    return cause instanceof Error ? cause.message : String(cause);
+}

package/dist/config/index.js

@@ -0,0 +1,11 @@
+export { AGENT_CLAUDE, AGENT_COPILOT, AGENT_VIBE, DEFAULT_AGENT, MAX_SETTINGS_SIZE, PROJECT_DIR, agents, isAgent, readAgentSetting, writeAgentSetting, } from "./agents.js";
+export { CONFIG_DIR, Config, OutputFile, createConfig, loadConfig } from "./config.js";
+export { LoadError, PathEscapeError, UnknownAgentError, ValidationError } from "./errors.js";
+export { PACKAGE_MANIFEST, readPackageName, readPackageVersion } from "./manifest.js";
+export { fill } from "./messages.js";
+export { isFileName, isRelativeDir, removeDir } from "./names.js";
+export { contain } from "./paths.js";
+export { SETTINGS_FILE } from "./settings.js";
+export { DOCUMENT_FIELD } from "./strict-json.js";
+export { INSTALL_TASKS_FILE, installedName, installedRenames, isSeedOnly, } from "./tasks.js";
+export { KIND_MULTISELECT, KIND_PROJECTS_LIST, KIND_SINGLE_SELECT, KIND_TEXT_LIST, WIZARD_FILE, singleSelectSection, } from "./wizard.js";

package/dist/config/manifest.js

@@ -0,0 +1,28 @@
+import { ValidationError } from "./errors.js";
+import { contain } from "./paths.js";
+import { JsonLocation, readJsonDocument, readObject, readString } from "./strict-json.js";
+/** The package manifest inside the package root. */
+export const PACKAGE_MANIFEST = "package.json";
+const VERSION_PATTERN = /^[0-9A-Za-z.+-]+$/;
+const PACKAGE_NAME_PATTERN = /^(@[a-z0-9-~][a-z0-9-._~]*\/)?[a-z0-9-~][a-z0-9-._~]*$/;
+/** Reads the version field of the package manifest. */
+export function readPackageVersion(packageRoot) {
+    return readManifestField(packageRoot, "version", VERSION_PATTERN);
+}
+/** Reads the name field of the package manifest; a missing name fails instead of guessing the npm uninstall command. */
+export function readPackageName(packageRoot) {
+    return readManifestField(packageRoot, "name", PACKAGE_NAME_PATTERN);
+}
+function readManifestField(packageRoot, key, pattern) {
+    const manifestPath = contain(packageRoot, PACKAGE_MANIFEST);
+    const at = new JsonLocation(PACKAGE_MANIFEST);
+    const manifest = readObject(readJsonDocument(manifestPath, PACKAGE_MANIFEST), at);
+    const value = Object.hasOwn(manifest, key) ? readString(manifest[key], at.key(key)) : "";
+    if (value === "") {
+        throw new ValidationError(PACKAGE_MANIFEST, key, "is required");
+    }
+    if (!pattern.test(value)) {
+        throw new ValidationError(PACKAGE_MANIFEST, key, "has an invalid format");
+    }
+    return value;
+}

package/dist/config/messages.js

@@ -0,0 +1,86 @@
+import { readStrictObject, readString } from "./strict-json.js";
+const MESSAGE_KEYS = [
+    "help",
+    "version",
+    "headerTitle",
+    "introTitle",
+    "introSubtitle",
+    "intro",
+    "outroTitle",
+    "outro",
+    "noTerminal",
+    "configLoadFailed",
+    "invalidConfig",
+    "installFailed",
+    "installCancelled",
+    "pathOutsideRoot",
+    "installing",
+    "fileKept",
+    "syncSourceMissing",
+    "syncFailed",
+    "synced",
+    "syncedReplaced",
+    "languagesInstalled",
+    "languagesNone",
+    "languagesFailed",
+    "sectionFileMissing",
+    "currentItems",
+    "noItems",
+    "emptySubmit",
+    "duplicateItem",
+    "itemsAdded",
+    "itemsUnchanged",
+    "selectedCount",
+    "noneSelected",
+    "modeTitle",
+    "modeInstall",
+    "modeUninstall",
+    "uninstallHeaderTitle",
+    "uninstallList",
+    "uninstallConfirm",
+    "uninstallYes",
+    "uninstallNo",
+    "uninstalling",
+    "uninstallCancelled",
+    "nothingToRemove",
+    "uninstallRemoved",
+    "uninstallPruned",
+    "uninstallKeptPlans",
+    "uninstallFailed",
+    "uninstallRemovedSoFar",
+    "uninstallNpmHint",
+    "uninstallNoTerminal",
+    "invalidAgent",
+    "linkCreated",
+    "linkExisted",
+    "linkSkipped",
+    "linkFailed",
+    "importsCreated",
+    "importsExisted",
+    "importsSkipped",
+    "importsFailed",
+    "linksFailed",
+    "uninstallImportsEntry",
+    "projectsUpdated",
+    "projectsSkipped",
+];
+/** Reads the messages object: every message is required and must be a non-empty string; unknown keys are rejected. */
+export function decodeMessages(value, at) {
+    const object = readStrictObject(value, at, MESSAGE_KEYS);
+    const messages = {};
+    for (const key of MESSAGE_KEYS) {
+        messages[key] = readMessage(object[key], at.key(key));
+    }
+    return messages;
+}
+function readMessage(value, at) {
+    if (value === undefined || value === "") {
+        throw at.error("is required");
+    }
+    return readString(value, at);
+}
+const PLACEHOLDER = /\{([^{}]+)\}/g;
+/** Replaces every {name} placeholder in template with its value in one pass; unknown placeholders stay. */
+export function fill(template, values) {
+    return template.replace(PLACEHOLDER, (placeholder, name) => Object.hasOwn(values, name) ? (values[name] ?? placeholder) : placeholder);
+}

package/dist/config/names.js

@@ -0,0 +1,40 @@
+import path from "node:path";
+const FORBIDDEN_NAME_CHARACTERS = /[/\\*]/;
+const NUL = "\u0000";
+const WINDOWS_DRIVE = /^[A-Za-z]:/;
+/** Reports whether name is a single plain path segment. */
+export function isFileName(name) {
+    return name !== "" && name !== "." && name !== ".." && !FORBIDDEN_NAME_CHARACTERS.test(name) && !name.includes(NUL);
+}
+/** Reports whether candidate is absolute on any platform, including a Windows drive. */
+export function isAbsolutePath(candidate) {
+    return path.posix.isAbsolute(candidate) || path.win32.isAbsolute(candidate) || WINDOWS_DRIVE.test(candidate);
+}
+/**
+ * Reports whether dir is a slash-separated relative path without empty,
+ * "." or ".." segments, so it can only point inside its root.
+ */
+export function isRelativeDir(dir) {
+    if (dir === "" || isAbsolutePath(dir)) {
+        return false;
+    }
+    return dir.split("/").every(isFileName);
+}
+/**
+ * Reports whether pattern looks like "<dir>/<prefix>*": relative, no "..",
+ * and scoped to the owned prefix, so the delete step can never touch
+ * entries the project owns.
+ */
+export function isRemovePattern(pattern, ownedPrefix) {
+    const separator = pattern.lastIndexOf("/");
+    const dir = pattern.slice(0, separator + 1);
+    const last = pattern.slice(separator + 1);
+    if (last !== `${ownedPrefix}*`) {
+        return false;
+    }
+    return dir === "" || isRelativeDir(dir.slice(0, -1));
+}
+/** Returns the directory part of a removeFirst pattern, relative to the sync target ("." for the target itself). */
+export function removeDir(pattern) {
+    return path.posix.dirname(pattern);
+}

package/dist/config/paths.js

@@ -0,0 +1,73 @@
+import fs from "node:fs";
+import path from "node:path";
+import { PathEscapeError } from "./errors.js";
+import { isAbsolutePath } from "./names.js";
+/**
+ * Joins the slash-separated elements onto root and returns the absolute
+ * result. Rejects absolute elements, results outside root, and existing
+ * symlinks that resolve outside root.
+ */
+export function contain(root, ...elements) {
+    const relative = path.posix.join(...elements);
+    if (isAbsolutePath(relative)) {
+        throw new PathEscapeError(relative, root);
+    }
+    const absoluteRoot = path.resolve(root);
+    const joined = path.join(absoluteRoot, ...relative.split("/"));
+    if (!isWithin(absoluteRoot, joined)) {
+        throw new PathEscapeError(relative, root);
+    }
+    assertNoSymlinkEscape(absoluteRoot, joined);
+    return joined;
+}
+function isWithin(root, candidate) {
+    const relative = path.relative(root, candidate);
+    if (path.isAbsolute(relative)) {
+        return false;
+    }
+    return relative !== ".." && !relative.startsWith(`..${path.sep}`);
+}
+/** Resolves the deepest existing part of candidate and verifies it still lies inside the resolved root. */
+function assertNoSymlinkEscape(root, candidate) {
+    const realRoot = realpathIfExists(root);
+    if (realRoot === undefined) {
+        return;
+    }
+    const resolved = fs.realpathSync(deepestExisting(root, candidate));
+    if (!isWithin(realRoot, resolved)) {
+        throw new PathEscapeError(candidate, root);
+    }
+}
+function realpathIfExists(target) {
+    try {
+        return fs.realpathSync(target);
+    }
+    catch (error) {
+        if (isMissingEntry(error)) {
+            return undefined;
+        }
+        throw error;
+    }
+}
+function deepestExisting(root, candidate) {
+    let current = candidate;
+    while (current !== root && path.dirname(current) !== current) {
+        if (existsWithoutFollowing(current)) {
+            return current;
+        }
+        current = path.dirname(current);
+    }
+    return root;
+}
+function existsWithoutFollowing(target) {
+    try {
+        fs.lstatSync(target);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function isMissingEntry(error) {
+    return error instanceof Error && "code" in error && error.code === "ENOENT";
+}

package/dist/config/settings.js

@@ -0,0 +1,101 @@
+import { JsonLocation, optional, readStrictObject, readString, readStringArrayRecord, readStringRecord, required, sortedKeys, toRecord, } from "./strict-json.js";
+import { isFileName } from "./names.js";
+import { ValidationError } from "./errors.js";
+/** Name of the settings config file. */
+export const SETTINGS_FILE = "settings.json";
+const HEX_COLOR = /^#[0-9a-fA-F]{6}$/;
+const OWNED_PREFIX = /^[a-z0-9]+(-[a-z0-9]+)*-$/;
+const LANGUAGE_TAG = /^[a-z0-9]+$/;
+const SETTINGS_KEYS = [
+    "brandColor",
+    "filePrefix",
+    "outputFileNames",
+    "settingsFileName",
+    "languagePattern",
+    "languageLabels",
+    "languageImplications",
+];
+export function decodeSettings(document) {
+    const at = new JsonLocation(SETTINGS_FILE);
+    const object = readStrictObject(document, at, SETTINGS_KEYS);
+    return {
+        brandColor: required(object, "brandColor", at, readString),
+        filePrefix: required(object, "filePrefix", at, readString),
+        outputFileNames: required(object, "outputFileNames", at, readStringRecord),
+        settingsFileName: required(object, "settingsFileName", at, readString),
+        languagePattern: required(object, "languagePattern", at, readString),
+        languageLabels: required(object, "languageLabels", at, readStringRecord),
+        languageImplications: optional(object, "languageImplications", at, readStringArrayRecord, toRecord([])),
+    };
+}
+export function validateSettings(settings) {
+    if (!HEX_COLOR.test(settings.brandColor)) {
+        throw settingsError("brandColor", "must be a hex colour like #0096ff");
+    }
+    if (!OWNED_PREFIX.test(settings.filePrefix)) {
+        throw settingsError("filePrefix", 'must be lowercase letters, digits and hyphens ending in "-"');
+    }
+    validateOutputFileNames(settings.outputFileNames);
+    if (!isFileName(settings.settingsFileName)) {
+        throw settingsError("settingsFileName", "must be a plain file name");
+    }
+    validateLanguageLabels(settings.languageLabels);
+    validateLanguageImplications(settings.languageImplications);
+    return { ...settings, languageRegExp: compileLanguagePattern(settings.languagePattern) };
+}
+function validateOutputFileNames(outputFileNames) {
+    const keys = sortedKeys(outputFileNames);
+    if (keys.length === 0) {
+        throw settingsError("outputFileNames", "must be a non-empty object");
+    }
+    const invalidKey = keys.find((key) => !isFileName(outputFileNames[key] ?? ""));
+    if (invalidKey !== undefined) {
+        throw settingsError(`outputFileNames.${invalidKey}`, "must be a plain file name");
+    }
+}
+function compileLanguagePattern(pattern) {
+    if (pattern === "") {
+        throw settingsError("languagePattern", "is required");
+    }
+    let compiled;
+    try {
+        compiled = new RegExp(pattern);
+    }
+    catch {
+        throw settingsError("languagePattern", "must be a valid regular expression");
+    }
+    if (countCaptureGroups(pattern) !== 1) {
+        throw settingsError("languagePattern", "must have exactly one capture group");
+    }
+    return compiled;
+}
+// An empty alternative always matches, so the match array has one slot per group.
+function countCaptureGroups(pattern) {
+    const match = new RegExp(`${pattern}|`).exec("");
+    return match === null ? 0 : match.length - 1;
+}
+function validateLanguageLabels(languageLabels) {
+    const invalidKey = sortedKeys(languageLabels).find((key) => key === "" || languageLabels[key] === "");
+    if (invalidKey !== undefined) {
+        throw settingsError(`languageLabels.${invalidKey}`, "must map a tag to a non-empty label");
+    }
+}
+/** Accepts no implications, but rejects any tag that is not lowercase letters and digits. */
+function validateLanguageImplications(implications) {
+    for (const key of sortedKeys(implications)) {
+        const field = `languageImplications.${key}`;
+        if (!LANGUAGE_TAG.test(key)) {
+            throw settingsError(field, "must be keyed by a language tag of lowercase letters and digits");
+        }
+        const implied = implications[key] ?? [];
+        if (implied.length === 0) {
+            throw settingsError(field, "must list at least one language tag");
+        }
+        if (!implied.every((tag) => LANGUAGE_TAG.test(tag))) {
+            throw settingsError(field, "must list language tags of lowercase letters and digits");
+        }
+    }
+}
+export function settingsError(field, problem) {
+    return new ValidationError(SETTINGS_FILE, field, problem);
+}

package/dist/config/strict-json.js

@@ -0,0 +1,119 @@
+import fs from "node:fs";
+import { LoadError, ValidationError } from "./errors.js";
+/** Field name used for problems with the document as a whole. */
+export const DOCUMENT_FIELD = "document";
+/** Where a value sits: its config file and the field path inside it. */
+export class JsonLocation {
+    file;
+    field;
+    constructor(file, field = "") {
+        this.file = file;
+        this.field = field;
+    }
+    key(name) {
+        return new JsonLocation(this.file, this.field === "" ? name : `${this.field}.${name}`);
+    }
+    index(position) {
+        return new JsonLocation(this.file, `${this.field}[${position}]`);
+    }
+    error(problem) {
+        return new ValidationError(this.file, this.field === "" ? DOCUMENT_FIELD : this.field, problem);
+    }
+}
+/** Reads and parses one JSON document; file names it in errors. */
+export function readJsonDocument(filePath, file) {
+    const text = readText(filePath, file);
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        throw new ValidationError(file, DOCUMENT_FIELD, "must contain exactly one valid JSON value");
+    }
+}
+function readText(filePath, file) {
+    try {
+        return fs.readFileSync(filePath, "utf8");
+    }
+    catch (error) {
+        throw new LoadError(file, error);
+    }
+}
+/** Reads an object whose keys must all be in allowedKeys. */
+export function readStrictObject(value, at, allowedKeys) {
+    const object = readObject(value, at);
+    const unknownKey = Object.keys(object).find((key) => !allowedKeys.includes(key));
+    if (unknownKey !== undefined) {
+        throw at.key(unknownKey).error("is not an allowed key");
+    }
+    return object;
+}
+/** Reads an object with arbitrary keys. */
+export function readObject(value, at) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        throw at.error(typeProblem("an object", value));
+    }
+    return value;
+}
+export function readString(value, at) {
+    if (typeof value !== "string") {
+        throw at.error(typeProblem("a string", value));
+    }
+    return value;
+}
+export function readArray(value, at, readItem) {
+    if (!Array.isArray(value)) {
+        throw at.error(typeProblem("an array", value));
+    }
+    return value.map((item, position) => readItem(item, at.index(position)));
+}
+export function readStringArray(value, at) {
+    return readArray(value, at, readString);
+}
+export function readStringRecord(value, at) {
+    return readRecord(value, at, readString);
+}
+export function readStringArrayRecord(value, at) {
+    return readRecord(value, at, readStringArray);
+}
+function readRecord(value, at, readEntry) {
+    const entries = Object.entries(readObject(value, at));
+    return toRecord(entries.map(([key, entry]) => [key, readEntry(entry, at.key(key))]));
+}
+/** Reads a key that must be present. */
+export function required(object, key, at, read) {
+    if (!Object.hasOwn(object, key)) {
+        throw at.key(key).error("is required");
+    }
+    return read(object[key], at.key(key));
+}
+/** Reads a key that may be absent; fallback stands in for it. */
+export function optional(object, key, at, read, fallback) {
+    return Object.hasOwn(object, key) ? read(object[key], at.key(key)) : fallback;
+}
+/**
+ * Builds a record without a prototype, so keys such as "__proto__" or
+ * "constructor" are plain data and lookups never hit inherited members.
+ */
+export function toRecord(entries) {
+    const record = Object.create(null);
+    for (const [key, value] of entries) {
+        Object.defineProperty(record, key, { value, enumerable: true });
+    }
+    return record;
+}
+/** Returns the keys of record in sorted order, for deterministic validation. */
+export function sortedKeys(record) {
+    return Object.keys(record).sort();
+}
+function typeProblem(expected, value) {
+    return `must be ${expected}, not ${describeKind(value)}`;
+}
+function describeKind(value) {
+    if (value === null) {
+        return "null";
+    }
+    if (Array.isArray(value)) {
+        return "an array";
+    }
+    return typeof value === "object" ? "an object" : `a ${typeof value}`;
+}