@reliantlabs/forge-web-runtime 0.13.2 → 0.13.4

package/dist/mock-values.js

@@ -0,0 +1,1222 @@
+// Part of @reliantlabs/forge-web-runtime — the web twin of forge/pkg.
+//
+// Default mock responses for ANY Connect service, built from its descriptor.
+//
+// The entity fixtures (mock-transport.ts) serve generated CRUD only: every
+// other RPC — a dashboard read, a search, a stream — used to need a
+// hand-written scenario handler before a mocked page rendered anything at
+// all. This module answers every RPC of every service with a deterministic,
+// schema-valid message, so a scenario writes only what it wants to SAY, not
+// the shape of the whole response:
+//
+//   serviceDefaults(Service)      every RPC's default handler (the generated
+//                                 src/mocks/services/*_gen.ts call this)
+//   mockService(Service, {...})   typed per-RPC overrides for a scenario,
+//                                 each handed the defaults to start from
+//   patch(message, {...})         deep-merge a change onto a default
+//   mockValue(Schema)             one message, for a test or a factory
+//
+// Values are built at RUNTIME from the descriptor, not emitted as literals.
+// protoc-gen-es embeds every file's FileDescriptorProto — options included —
+// in its `_pb.ts`, so the protovalidate rules (min/max, len, pattern, `in`,
+// formats) are read off `field.proto.options` (mock-rules.ts), with no buf.validate
+// TypeScript in the app and no per-project codegen beyond one import per
+// service. A vendored contract (another repo's protos, generated by its own
+// buf template) works the same as the project's own.
+//
+// What a value is, by field (the field's NAME is a hint, never vocabulary —
+// forge does not invent a domain the schema does not declare):
+//
+//   `id` / `*_id`        a stable id: `<thing>-<8 hex>`; `trace_id` and
+//                        `span_id` are 32/16 hex, as OpenTelemetry's are
+//   Timestamp, `*_at`    recent times; list items newest first; within one
+//                        message, `start*`/`created*` precede `end*`/`updated*`
+//   `email`, `url`, ...  example.com addresses and links
+//   `name`, `title`      "<Message> <n>", numbered by list position
+//   other strings        "<field>-<n>"
+//   numbers              a range the name suggests (`*_ms`, `count`, `port`,
+//                        `percent`, `*_bytes`, ...), else 1..100
+//   enums                cycle through the defined values (skipping the
+//                        zero UNSPECIFIED) across a list's items
+//   repeated             3–10 items; maps 3–5 entries
+//   oneof                one member, chosen by the seed
+//   Duration, Struct, Value, wrappers   handled as their JSON forms suggest
+//   `next_page_token`    always "" — a mock that pages forever is a bug
+//
+// Then the field's protovalidate rules constrain it: `const` and `in` win,
+// numbers are clamped into gt/gte/lt/lte, strings meet len/min_len/max_len,
+// prefix/suffix/contains, the well-known formats (email, uri, uuid, hostname,
+// ip, ulid) and, where it is cheap, `pattern`. Repeated and map sizes honour
+// min_items/max_items and min_pairs/max_pairs. CEL rules are not evaluated.
+//
+// Determinism: every value is a function of (seed, field path). The seed of a
+// default handler is the method plus the request's wire bytes, so the same
+// request always gets the same answer, and a field added to a message does not
+// reshuffle the others. Scalar fields that the REQUEST also carries (by name
+// and type) echo the request — `GetWorkload{id}` answers that id, and a filter
+// field reads back as filtered — except paging and query controls.
+import { create, isMessage, ScalarType, toBinary, } from "@bufbuild/protobuf";
+import { rulesOf, } from "./mock-rules.js";
+/**
+ * Typed factory helper: `mockFactory(TraceSummarySchema, ({ base, index }) =>
+ * ({ rootService: index % 2 ? "web" : "api" }))` — the result is patched onto
+ * the default for every TraceSummary the engine builds.
+ */
+export function mockFactory(schema, build) {
+    return { schema, build };
+}
+// ── Determinism ─────────────────────────────────────────────────────────
+/** FNV-1a, 32-bit: small, fast, and stable across engines. */
+function fnv1a(input) {
+    let h = 0x811c9dc5;
+    if (typeof input === "string") {
+        for (let i = 0; i < input.length; i++) {
+            h ^= input.charCodeAt(i);
+            h = Math.imul(h, 0x01000193);
+        }
+    }
+    else {
+        for (const b of input) {
+            h ^= b;
+            h = Math.imul(h, 0x01000193);
+        }
+    }
+    return h >>> 0;
+}
+/** mulberry32 over an FNV-1a seed: a deterministic stream per (seed, path). */
+class Rng {
+    state;
+    constructor(seed) {
+        this.state = fnv1a(seed) || 0x9e3779b9;
+    }
+    next() {
+        this.state = (this.state + 0x6d2b79f5) | 0;
+        let t = this.state;
+        t = Math.imul(t ^ (t >>> 15), t | 1);
+        t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+        return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+    }
+    /** An integer in [lo, hi], inclusive. */
+    int(lo, hi) {
+        if (hi <= lo)
+            return lo;
+        return lo + Math.floor(this.next() * (hi - lo + 1));
+    }
+    pick(items) {
+        return items[this.int(0, items.length - 1)];
+    }
+    hex(n) {
+        let out = "";
+        while (out.length < n)
+            out += this.int(0, 15).toString(16);
+        return out;
+    }
+}
+let sessionNow;
+function anchorMs(now) {
+    if (now !== undefined)
+        return typeof now === "number" ? now : now.getTime();
+    sessionNow ??= Math.floor(Date.now() / 60_000) * 60_000;
+    return sessionNow;
+}
+// ── Names ───────────────────────────────────────────────────────────────
+const words = (s) => s
+    .replace(/([a-z0-9])([A-Z])/g, "$1_$2")
+    .toLowerCase()
+    .split(/[^a-z0-9]+/)
+    .filter(Boolean);
+const kebab = (s) => words(s).join("-");
+/** `labels` → `label`, `entries` → `entry`: a list item is one of the list. */
+function singularOf(s) {
+    if (/ies$/.test(s))
+        return s.slice(0, -3) + "y";
+    if (/(ss|us|is)$/.test(s))
+        return s;
+    return s.replace(/s$/, "");
+}
+function human(s) {
+    const w = words(s).join(" ");
+    return w.charAt(0).toUpperCase() + w.slice(1);
+}
+/** The thing a message stands for: `ListTracesResponse` → `List traces`. */
+function messageNoun(desc) {
+    return desc.name.replace(/(Request|Response)$/, "") || desc.name;
+}
+function hasWord(name, ...candidates) {
+    const w = words(name);
+    return candidates.some((c) => w.includes(c));
+}
+// ── Strings ─────────────────────────────────────────────────────────────
+/** Paging and query controls: echoing or inventing them misleads the caller. */
+const CONTROL_FIELDS = new Set([
+    "page_size",
+    "page_token",
+    "next_page_token",
+    "order_by",
+    "query",
+    "search",
+    "filter",
+    "limit",
+    "offset",
+    "cursor",
+]);
+function uuidFrom(rng) {
+    const h = rng.hex(32);
+    return `${h.slice(0, 8)}-${h.slice(8, 12)}-4${h.slice(13, 16)}-${"89ab"[rng.int(0, 3)]}${h.slice(17, 20)}-${h.slice(20)}`;
+}
+function formatted(format, rng, n) {
+    switch (format) {
+        case "email":
+            return `user-${n}@example.com`;
+        case "uri":
+            return `https://example.com/${rng.hex(8)}`;
+        case "hostname":
+        case "address":
+            return `host-${n}.example.com`;
+        case "hostAndPort":
+            return `host-${n}.example.com:8080`;
+        case "ip":
+        case "ipv4":
+            return `10.${rng.int(0, 255)}.${rng.int(0, 255)}.${rng.int(1, 254)}`;
+        case "ipv6":
+            return `fd00::${rng.hex(4)}`;
+        case "ipPrefix":
+            return `10.${rng.int(0, 255)}.0.0/16`;
+        case "uuid":
+            return uuidFrom(rng);
+        case "tuuid":
+            return rng.hex(32);
+        case "ulid": {
+            const alphabet = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+            let s = "01";
+            while (s.length < 26)
+                s += alphabet[rng.int(0, 31)];
+            return s;
+        }
+    }
+}
+/** A string for a field, from its name alone (before any rule applies). */
+function stringByName(name, owner, n, rng, listItem = false) {
+    const w = words(name);
+    const last = w[w.length - 1] ?? "";
+    if (name === "next_page_token" ||
+        name === "page_token" ||
+        name === "cursor") {
+        return "";
+    }
+    if (name === "trace_id")
+        return rng.hex(32);
+    if (name === "span_id" || name === "parent_span_id")
+        return rng.hex(16);
+    if (last === "uuid")
+        return uuidFrom(rng);
+    if (name === "id")
+        return `${kebab(messageNoun(owner))}-${rng.hex(8)}`;
+    if (last === "id" || last === "ids") {
+        const thing = w.slice(0, -1).join("-") || "id";
+        return `${thing}-${rng.hex(8)}`;
+    }
+    if (last === "email" || last === "emails")
+        return `user-${n}@example.com`;
+    if (["url", "uri", "link", "href", "endpoint", "website"].includes(last)) {
+        return `https://example.com/${w.slice(0, -1).join("-") || "item"}/${n}`;
+    }
+    if (["host", "hostname", "domain", "fqdn"].includes(last)) {
+        return `host-${n}.example.com`;
+    }
+    if (last === "ip" || name === "ip_address") {
+        return `10.0.${rng.int(0, 255)}.${rng.int(1, 254)}`;
+    }
+    if (last === "phone")
+        return `+1-555-01${String(n % 100).padStart(2, "0")}`;
+    if (last === "version")
+        return `1.${rng.int(0, 20)}.${rng.int(0, 9)}`;
+    if (last === "color" || last === "colour")
+        return `#${rng.hex(6)}`;
+    if (["sha", "commit", "hash", "etag", "fingerprint"].includes(last))
+        return rng.hex(40);
+    if (last === "digest")
+        return `sha256:${rng.hex(64)}`;
+    if (last === "token" ||
+        last === "secret" ||
+        (last === "key" && w.includes("api"))) {
+        return `tok_${rng.hex(24)}`;
+    }
+    if (last === "json")
+        return "{}";
+    if (last === "locale" || last === "language")
+        return "en-US";
+    if (last === "currency")
+        return "USD";
+    if (last === "country")
+        return "US";
+    if (last === "timezone" || name === "tz")
+        return "UTC";
+    if (["name", "title", "label"].includes(name) || name === "display_name") {
+        return `${human(messageNoun(owner))} ${n}`;
+    }
+    if (last === "name" || last === "title") {
+        return `${human(w.slice(0, -1).join("_"))} ${n}`;
+    }
+    if ([
+        "description",
+        "summary",
+        "message",
+        "body",
+        "text",
+        "details",
+        "detail",
+        "reason",
+        "comment",
+        "note",
+        "notes",
+        "content",
+        "error",
+    ].includes(last)) {
+        return `Sample ${human(messageNoun(owner)).toLowerCase()} ${w.join(" ")} ${n}.`;
+    }
+    return `${kebab(listItem ? singularOf(name) : name)}-${n}`;
+}
+/** The smallest string matching a cheap regex, or undefined when it is not cheap. */
+function fromPattern(pattern, rng) {
+    let i = 0;
+    const src = pattern;
+    const charClass = () => {
+        // At "[" — collect ranges; a negated class picks the first printable miss.
+        i++;
+        const negate = src[i] === "^";
+        if (negate)
+            i++;
+        const ranges = [];
+        let first = true;
+        while (i < src.length && (src[i] !== "]" || first)) {
+            first = false;
+            let c = src[i++];
+            if (c === "\\") {
+                const e = src[i++];
+                if (e === "d") {
+                    ranges.push([48, 57]);
+                    continue;
+                }
+                if (e === "w") {
+                    ranges.push([97, 122], [65, 90], [48, 57], [95, 95]);
+                    continue;
+                }
+                if (e === "s") {
+                    ranges.push([32, 32]);
+                    continue;
+                }
+                c = e;
+            }
+            if (src[i] === "-" && src[i + 1] !== "]" && i + 1 < src.length) {
+                i++;
+                let hi = src[i++];
+                if (hi === "\\")
+                    hi = src[i++];
+                ranges.push([c.charCodeAt(0), hi.charCodeAt(0)]);
+            }
+            else {
+                ranges.push([c.charCodeAt(0), c.charCodeAt(0)]);
+            }
+        }
+        i++; // "]"
+        if (negate) {
+            return () => {
+                for (let code = 97; code < 127; code++) {
+                    if (!ranges.some(([lo, hi]) => code >= lo && code <= hi)) {
+                        return String.fromCharCode(code);
+                    }
+                }
+                return "_";
+            };
+        }
+        return () => {
+            const [lo, hi] = rng.pick(ranges);
+            return String.fromCharCode(rng.int(lo, hi));
+        };
+    };
+    const atom = () => {
+        const c = src[i];
+        if (c === "(") {
+            i++;
+            if (src[i] === "?") {
+                if (src[i + 1] !== ":")
+                    return undefined; // lookarounds: not cheap
+                i += 2;
+            }
+            const inner = alternation();
+            if (src[i] !== ")" || !inner)
+                return undefined;
+            i++;
+            return inner;
+        }
+        if (c === "[")
+            return charClass();
+        if (c === ".") {
+            i++;
+            return () => String.fromCharCode(rng.int(97, 122));
+        }
+        if (c === "\\") {
+            const e = src[i + 1];
+            i += 2;
+            if (e === "d")
+                return () => String(rng.int(0, 9));
+            if (e === "w")
+                return () => String.fromCharCode(rng.int(97, 122));
+            if (e === "s")
+                return () => " ";
+            if (/[A-Za-z]/.test(e))
+                return undefined; // \b, \p{..}, ...: not cheap
+            return () => e;
+        }
+        i++;
+        return () => c;
+    };
+    const sequence = () => {
+        const parts = [];
+        while (i < src.length && src[i] !== "|" && src[i] !== ")") {
+            if (src[i] === "^" || src[i] === "$") {
+                i++;
+                continue;
+            }
+            const a = atom();
+            if (!a)
+                return undefined;
+            let min = 1;
+            let max = 1;
+            const q = src[i];
+            if (q === "?" || q === "*" || q === "+") {
+                i++;
+                min = q === "+" ? 1 : 0;
+                max = q === "?" ? 1 : min + 3;
+            }
+            else if (q === "{") {
+                const m = /^\{(\d+)(,(\d*))?\}/.exec(src.slice(i));
+                if (!m)
+                    return undefined;
+                i += m[0].length;
+                min = Number(m[1]);
+                max = m[2] ? (m[3] ? Number(m[3]) : min + 3) : min;
+            }
+            if (src[i] === "?")
+                i++; // lazy: same strings
+            const lo = min;
+            const hi = Math.min(max, min + 3);
+            parts.push(() => {
+                let s = "";
+                const count = rng.int(Math.max(lo, 1), Math.max(hi, 1));
+                for (let k = 0; k < (lo === 0 && hi === 0 ? 0 : count); k++)
+                    s += a();
+                return s;
+            });
+        }
+        return () => parts.map((p) => p()).join("");
+    };
+    const alternation = () => {
+        const branches = [];
+        for (;;) {
+            const s = sequence();
+            if (!s)
+                return undefined;
+            branches.push(s);
+            if (src[i] !== "|")
+                break;
+            i++;
+        }
+        return () => rng.pick(branches)();
+    };
+    try {
+        const re = new RegExp(pattern, "u");
+        const node = alternation();
+        if (!node || i < src.length)
+            return undefined;
+        for (let attempt = 0; attempt < 8; attempt++) {
+            const s = node();
+            if (re.test(s))
+                return s;
+        }
+    }
+    catch {
+        // An RE2 construct JavaScript does not accept: not cheap.
+    }
+    return undefined;
+}
+function applyStringRules(value, rules, rng, n) {
+    if (rules.const !== undefined)
+        return rules.const;
+    if (rules.in?.length)
+        return rng.pick(rules.in);
+    let s = value;
+    if (rules.format)
+        s = formatted(rules.format, rng, n);
+    if (rules.pattern) {
+        let ok = false;
+        try {
+            ok = new RegExp(rules.pattern, "u").test(s);
+        }
+        catch {
+            ok = true; // not JavaScript-parsable: leave the value alone
+        }
+        if (!ok)
+            s = fromPattern(rules.pattern, rng) ?? s;
+    }
+    if (rules.prefix && !s.startsWith(rules.prefix))
+        s = rules.prefix + s;
+    if (rules.suffix && !s.endsWith(rules.suffix))
+        s = s + rules.suffix;
+    if (rules.contains && !s.includes(rules.contains))
+        s = s + rules.contains;
+    if (rules.notIn?.includes(s))
+        s = `${s}-${n}`;
+    const min = rules.len ?? rules.minLen;
+    const max = rules.len ?? rules.maxLen;
+    const chars = [...s];
+    if (max !== undefined && chars.length > max) {
+        s = chars.slice(0, max).join("");
+    }
+    else if (min !== undefined && chars.length < min) {
+        s = s + "x".repeat(min - chars.length);
+    }
+    return s;
+}
+// ── Numbers ─────────────────────────────────────────────────────────────
+const INT_LIMITS = {
+    [ScalarType.INT32]: [-2147483648, 2147483647],
+    [ScalarType.SINT32]: [-2147483648, 2147483647],
+    [ScalarType.SFIXED32]: [-2147483648, 2147483647],
+    [ScalarType.UINT32]: [0, 4294967295],
+    [ScalarType.FIXED32]: [0, 4294967295],
+    [ScalarType.UINT64]: [0, Number.MAX_SAFE_INTEGER],
+    [ScalarType.FIXED64]: [0, Number.MAX_SAFE_INTEGER],
+    [ScalarType.INT64]: [-Number.MAX_SAFE_INTEGER, Number.MAX_SAFE_INTEGER],
+    [ScalarType.SINT64]: [-Number.MAX_SAFE_INTEGER, Number.MAX_SAFE_INTEGER],
+    [ScalarType.SFIXED64]: [-Number.MAX_SAFE_INTEGER, Number.MAX_SAFE_INTEGER],
+};
+const isFloat = (t) => t === ScalarType.DOUBLE || t === ScalarType.FLOAT;
+const is64 = (t) => t === ScalarType.INT64 ||
+    t === ScalarType.UINT64 ||
+    t === ScalarType.SINT64 ||
+    t === ScalarType.FIXED64 ||
+    t === ScalarType.SFIXED64;
+/** Epoch unit a time-valued integer field is in, from its name. */
+function epochUnit(name) {
+    const w = words(name);
+    const timeish = hasWord(name, "unix", "epoch", "timestamp", "at") ||
+        (w[w.length - 1] === "time" && !hasWord(name, "duration", "elapsed")) ||
+        (w.includes("time") &&
+            hasWord(name, "nano", "nanos", "ns", "ms", "millis"));
+    if (!timeish || hasWord(name, "duration", "latency", "elapsed", "took"))
+        return undefined;
+    if (hasWord(name, "nano", "nanos", "ns"))
+        return 1e6;
+    if (hasWord(name, "us", "micros"))
+        return 1e3;
+    if (hasWord(name, "ms", "millis"))
+        return 1;
+    return 1e-3;
+}
+/** The range a number's name suggests: [lo, hi]. */
+function numberRange(name, float) {
+    const durationish = hasWord(name, "duration", "latency", "elapsed", "took", "time");
+    if (durationish || hasWord(name, "ms", "millis")) {
+        if (hasWord(name, "ns", "nanos", "nano"))
+            return [100_000, 2_000_000_000];
+        if (hasWord(name, "us", "micros"))
+            return [100, 2_000_000];
+        if (hasWord(name, "seconds", "secs", "s", "sec"))
+            return float ? [0.01, 5] : [1, 120];
+        return [1, 2000];
+    }
+    if (hasWord(name, "seconds", "secs"))
+        return [1, 3600];
+    if (hasWord(name, "percent", "pct", "percentage"))
+        return [0, 100];
+    if (hasWord(name, "ratio", "fraction", "share", "probability", "rate") &&
+        float)
+        return [0, 1];
+    if (hasWord(name, "rate"))
+        return [0, 100];
+    if (hasWord(name, "bytes", "size") && !hasWord(name, "page"))
+        return [1024, 104_857_600];
+    if (hasWord(name, "port"))
+        return [1024, 65535];
+    if (hasWord(name, "year"))
+        return [2020, 2026];
+    if (hasWord(name, "month"))
+        return [1, 12];
+    if (hasWord(name, "day"))
+        return [1, 28];
+    if (hasWord(name, "hour"))
+        return [0, 23];
+    if (hasWord(name, "minute", "second"))
+        return [0, 59];
+    if (hasWord(name, "lat", "latitude"))
+        return [-90, 90];
+    if (hasWord(name, "lng", "lon", "longitude"))
+        return [-180, 180];
+    if (hasWord(name, "version", "revision", "generation", "attempt", "attempts", "retry", "retries", "priority", "level", "rank")) {
+        return [1, 10];
+    }
+    if (name === "severity_number")
+        return [1, 24];
+    if (hasWord(name, "cents", "price", "amount", "cost"))
+        return float ? [1, 1000] : [100, 100_000];
+    if (hasWord(name, "count", "total", "num", "number", "length", "requests", "errors", "hits", "calls", "events", "items", "value")) {
+        return [0, 1000];
+    }
+    return float ? [0, 1000] : [1, 100];
+}
+/** Clamp/choose a number by its rules. `step` is 1 for integers. */
+function applyNumRules(value, rules, rng, float) {
+    if (!rules)
+        return value;
+    if (rules.const !== undefined)
+        return rules.const;
+    if (rules.in?.length)
+        return rng.pick(rules.in);
+    const eps = float ? 0.01 : 1;
+    let lo = -Infinity;
+    let hi = Infinity;
+    if (rules.gte !== undefined)
+        lo = rules.gte;
+    if (rules.gt !== undefined)
+        lo = Math.max(lo, rules.gt + eps);
+    if (rules.lte !== undefined)
+        hi = rules.lte;
+    if (rules.lt !== undefined)
+        hi = Math.min(hi, rules.lt - eps);
+    let v = value;
+    // protovalidate allows an exclusive range (gt > lt: outside the band); then
+    // either side is valid, and the value already on one side is kept.
+    const exclusive = lo > hi;
+    if (!exclusive) {
+        if (v < lo || v > hi) {
+            const width = Number.isFinite(hi - lo) ? hi - lo : 100;
+            v =
+                lo === -Infinity
+                    ? hi - rng.next() * Math.min(width, 100)
+                    : lo + rng.next() * Math.min(width, 100);
+        }
+        v = Math.min(Math.max(v, lo), hi);
+    }
+    else if (v < lo && v > hi) {
+        v = lo;
+    }
+    if (!float)
+        v = Math.round(v);
+    if (!float && rules.gt !== undefined && v <= rules.gt)
+        v = rules.gt + 1;
+    if (!float && rules.lt !== undefined && v >= rules.lt)
+        v = rules.lt - 1;
+    for (let k = 0; rules.notIn?.includes(v) && k < 100; k++)
+        v += eps;
+    return v;
+}
+/** Two decimals, unless rounding would step outside the rules' bounds. */
+function roundWithin(v, rules) {
+    if (rules?.const !== undefined || rules?.in?.length)
+        return v;
+    const r = Math.round(v * 100) / 100;
+    const lo = rules?.gt ?? rules?.gte ?? -Infinity;
+    const hi = rules?.lt ?? rules?.lte ?? Infinity;
+    const inside = r >= lo && r <= hi && r !== rules?.gt && r !== rules?.lt;
+    return inside ? r : v;
+}
+const rngAt = (ctx, key) => new Rng(`${ctx.seed}|${ctx.path}.${key}`);
+/** The number list items are labelled with: their position, else a small stable one. */
+const ordinal = (ctx, rng) => ctx.index >= 0 ? ctx.index + 1 : rng.int(1, 9);
+/** Schemas the engine has walked, so `patch` can rebuild a nested message. */
+const knownSchemas = new Map();
+function collectEcho(schema, message) {
+    const out = new Map();
+    const walk = (desc, msg, depth) => {
+        for (const f of desc.fields) {
+            if (f.oneof)
+                continue;
+            const v = msg[f.localName];
+            if (v == null)
+                continue;
+            if (f.fieldKind === "scalar") {
+                if (f.scalar === ScalarType.BOOL || f.scalar === ScalarType.BYTES)
+                    continue;
+                if (v === "" || v === 0 || v === 0n || CONTROL_FIELDS.has(f.name))
+                    continue;
+                if (!out.has(f.name))
+                    out.set(f.name, { value: v, scalar: f.scalar });
+            }
+            else if (f.fieldKind === "enum") {
+                if (v === 0)
+                    continue;
+                if (!out.has(f.name))
+                    out.set(f.name, { value: v, enumType: f.enum.typeName });
+            }
+            else if (f.fieldKind === "message" && depth < 2 && isMessage(v)) {
+                walk(f.message, v, depth + 1);
+            }
+        }
+    };
+    walk(schema, message, 0);
+    return out;
+}
+function echoFor(ctx, name, scalar, enumType) {
+    // A bare `id` is the record's own key: echo it only on the answer's top
+    // record, never on list items or nested records (they would all collide).
+    if (name === "id" && (ctx.index >= 0 || ctx.depth > 1))
+        return undefined;
+    if (CONTROL_FIELDS.has(name))
+        return undefined;
+    const e = ctx.echo.get(name);
+    if (!e)
+        return undefined;
+    if (scalar !== undefined && e.scalar !== scalar) {
+        // Same family is good enough: an int32 filter echoes into an int64 field.
+        const fam = (t) => t === undefined
+            ? "?"
+            : t === ScalarType.STRING
+                ? "s"
+                : isFloat(t)
+                    ? "f"
+                    : "i";
+        if (fam(e.scalar) !== fam(scalar))
+            return undefined;
+    }
+    if (enumType !== undefined && e.enumType !== enumType)
+        return undefined;
+    return e;
+}
+function scalarValue(scalar, name, owner, rules, ctx, longAsString) {
+    const rng = rngAt(ctx, name);
+    const n = ordinal(ctx, rng);
+    const echo = echoFor(ctx, name, scalar);
+    if (echo)
+        return coerceScalar(scalar, echo.value, longAsString);
+    switch (scalar) {
+        case ScalarType.STRING: {
+            const s = stringByName(name, owner, n, rng, ctx.index >= 0);
+            return rules?.str ? applyStringRules(s, rules.str, rng, n) : s;
+        }
+        case ScalarType.BOOL: {
+            if (rules?.bool !== undefined)
+                return rules.bool;
+            const likely = hasWord(name, "enabled", "active", "healthy", "success", "ok", "valid", "available", "ready", "visible", "verified", "public");
+            const rare = hasWord(name, "deleted", "disabled", "failed", "error", "errors", "truncated", "partial", "archived", "hidden", "locked", "null", "unknown", "expired", "revoked", "blocked", "provisional", "only");
+            return rng.next() < (likely ? 0.85 : rare ? 0.15 : 0.5);
+        }
+        case ScalarType.BYTES: {
+            const len = bytesLength(owner, name, rules?.bytes);
+            const out = new Uint8Array(len);
+            for (let k = 0; k < len; k++)
+                out[k] = rng.int(0, 255);
+            return out;
+        }
+        default: {
+            const float = isFloat(scalar);
+            const unit = float ? undefined : epochUnit(name);
+            let v;
+            if (unit !== undefined && is64(scalar)) {
+                // Epoch values: exact, so they are generated in bigint space.
+                const ms = ctx.baseTime - rng.int(0, 30_000);
+                const big = unit >= 1 ? BigInt(ms) * BigInt(unit) : BigInt(Math.floor(ms / 1000));
+                return longAsString ? big.toString() : big;
+            }
+            else if (unit !== undefined) {
+                v = Math.floor((ctx.baseTime - rng.int(0, 30_000)) / 1000);
+            }
+            else {
+                const [lo, hi] = numberRange(name, float);
+                v = float
+                    ? Math.round((lo + rng.next() * (hi - lo)) * 100) / 100
+                    : rng.int(lo, hi);
+            }
+            v = applyNumRules(v, rules?.num, rng, float);
+            if (float)
+                v = roundWithin(v, rules?.num);
+            const limits = INT_LIMITS[scalar];
+            if (limits)
+                v = Math.min(Math.max(Math.round(v), limits[0]), limits[1]);
+            return coerceScalar(scalar, v, longAsString);
+        }
+    }
+}
+/**
+ * Length of a generated bytes value: 16 unless the rules say otherwise.
+ * Bounds no value can satisfy throw, naming the field, rather than emit a
+ * value the server's protovalidate would reject.
+ */
+function bytesLength(owner, name, b) {
+    const min = Math.max(b?.len ?? 0, b?.minLen ?? 0);
+    const max = Math.min(b?.len ?? Infinity, b?.maxLen ?? Infinity);
+    if (min > max)
+        throw new Error(`mock values: ${owner.typeName}.${name} has bytes rules no value satisfies ` +
+            `(len ${b?.len ?? "-"}, min_len ${b?.minLen ?? "-"}, max_len ${b?.maxLen ?? "-"})`);
+    return Math.min(Math.max(16, min), max);
+}
+function coerceScalar(scalar, v, longAsString) {
+    if (is64(scalar)) {
+        const big = typeof v === "bigint" ? v : BigInt(Math.round(Number(v)));
+        return longAsString ? big.toString() : big;
+    }
+    if (scalar === ScalarType.STRING)
+        return String(v);
+    if (typeof v === "bigint")
+        return Number(v);
+    return v;
+}
+function enumValue(e, name, rules, ctx) {
+    const echo = echoFor(ctx, name, undefined, e.typeName);
+    if (echo)
+        return echo.value;
+    const r = rules?.enm;
+    if (r?.const !== undefined)
+        return r.const;
+    let values = e.values.map((v) => v.number);
+    // Skip the proto3 zero ("UNSPECIFIED") when anything else is defined.
+    if (values.length > 1)
+        values = values.filter((v) => v !== 0);
+    if (r?.in?.length)
+        values = values.filter((v) => r.in.includes(v));
+    if (r?.notIn?.length)
+        values = values.filter((v) => !r.notIn.includes(v));
+    if (values.length === 0)
+        return r?.in?.[0] ?? e.values[0]?.number ?? 0;
+    // Cycle across a list: item i takes value (offset + i), so a list of n
+    // items shows every value once before any repeats.
+    const offset = new Rng(`${ctx.seed}|${ctx.path.replace(/\[\d+\]/g, "")}.${name}`).int(0, values.length - 1);
+    const i = ctx.index >= 0 ? ctx.index : 0;
+    return values[(offset + i) % values.length];
+}
+/** Recent instant for a Timestamp field, respecting start/end order and rules. */
+function timestampMs(name, rules, ctx) {
+    const rng = rngAt(ctx, name);
+    let ms;
+    if (hasWord(name, "end", "ended", "finish", "finished", "completed", "updated", "last", "stop", "stopped", "until", "to", "modified", "resolved", "closed")) {
+        ms = ctx.baseTime;
+    }
+    else if (hasWord(name, "start", "started", "created", "first", "since", "from", "begin", "opened", "submitted")) {
+        ms = ctx.baseTime - rng.int(1_000, 120_000);
+    }
+    else if (hasWord(name, "expires", "expiry", "expiration", "deadline", "due", "next", "scheduled")) {
+        ms = ctx.now + rng.int(3_600_000, 7 * 86_400_000);
+    }
+    else {
+        ms = ctx.baseTime - rng.int(0, 30_000);
+    }
+    const t = rules?.timestamp;
+    if (t) {
+        if (t.const !== undefined)
+            return t.const;
+        if (t.gtNow)
+            ms = Math.max(ms, ctx.now + rng.int(60_000, 86_400_000));
+        if (t.ltNow)
+            ms = Math.min(ms, ctx.now - 1_000);
+        if (t.withinMs !== undefined)
+            ms = Math.min(Math.max(ms, ctx.now - t.withinMs + 1_000), ctx.now + t.withinMs - 1_000);
+        ms = applyNumRules(ms, t, rng, false);
+    }
+    return ms;
+}
+function timestampInit(ms) {
+    const seconds = Math.floor(ms / 1000);
+    return { seconds: BigInt(seconds), nanos: (ms - seconds * 1000) * 1_000_000 };
+}
+function durationInit(name, rules, ctx) {
+    const rng = rngAt(ctx, name);
+    let seconds = hasWord(name, "timeout", "ttl", "interval", "period", "window", "retention", "expiry", "max", "age")
+        ? rng.int(30, 3600)
+        : Math.round((0.005 + rng.next() * 5) * 1000) / 1000;
+    seconds = applyNumRules(seconds, rules?.duration, rng, true);
+    const ms = Math.round(seconds * 1000) / 1000;
+    const d = rules?.duration;
+    if ((d?.gt === undefined || ms > d.gt) &&
+        (d?.gte === undefined || ms >= d.gte) &&
+        (d?.lt === undefined || ms < d.lt) &&
+        (d?.lte === undefined || ms <= d.lte)) {
+        seconds = ms;
+    }
+    const whole = Math.floor(seconds);
+    return { seconds: BigInt(whole), nanos: Math.round((seconds - whole) * 1e9) };
+}
+function jsonObject(name, ctx) {
+    const rng = rngAt(ctx, name);
+    const out = {};
+    const stem = kebab(name).replace(/s$/, "") || "key";
+    const count = rng.int(2, 4);
+    for (let k = 1; k <= count; k++)
+        out[`${stem}-${k}`] = `value-${k}`;
+    return out;
+}
+const WKT_TIMESTAMP = "google.protobuf.Timestamp";
+const WKT_DURATION = "google.protobuf.Duration";
+const WKT_STRUCT = "google.protobuf.Struct";
+const WKT_VALUE = "google.protobuf.Value";
+const WKT_LIST_VALUE = "google.protobuf.ListValue";
+const WRAPPERS = new Set([
+    "google.protobuf.DoubleValue",
+    "google.protobuf.FloatValue",
+    "google.protobuf.Int64Value",
+    "google.protobuf.UInt64Value",
+    "google.protobuf.Int32Value",
+    "google.protobuf.UInt32Value",
+    "google.protobuf.BoolValue",
+    "google.protobuf.StringValue",
+    "google.protobuf.BytesValue",
+]);
+const LEAVE_UNSET = new Set([
+    "google.protobuf.Any",
+    "google.protobuf.FieldMask",
+    "google.protobuf.Empty",
+]);
+/**
+ * The init value for one message-typed position. `unboxed` is true where
+ * protobuf-es represents a wrapper as its primitive and a Struct as a
+ * JsonObject (a singular field outside a oneof; Struct in lists too).
+ */
+function messageAt(msg, name, owner, rules, ctx, unboxed) {
+    switch (msg.typeName) {
+        case WKT_TIMESTAMP:
+            return timestampInit(timestampMs(name, rules, ctx));
+        case WKT_DURATION:
+            return durationInit(name, rules, ctx);
+        case WKT_STRUCT:
+            return unboxed ? jsonObject(name, ctx) : undefined;
+        case WKT_VALUE:
+            return {
+                kind: {
+                    case: "stringValue",
+                    value: `${kebab(name)}-${ordinal(ctx, rngAt(ctx, name))}`,
+                },
+            };
+        case WKT_LIST_VALUE:
+            return {
+                values: [1, 2, 3].map((k) => ({
+                    kind: { case: "stringValue", value: `${kebab(name)}-${k}` },
+                })),
+            };
+    }
+    if (WRAPPERS.has(msg.typeName)) {
+        const inner = msg.fields[0];
+        if (!inner || inner.fieldKind !== "scalar")
+            return undefined;
+        const v = scalarValue(inner.scalar, name, owner, rules, ctx, inner.longAsString);
+        return unboxed ? v : { value: v };
+    }
+    if (LEAVE_UNSET.has(msg.typeName))
+        return undefined;
+    // Depth and recursion guards: a self-referencing type nests once.
+    if (ctx.depth >= ctx.maxDepth)
+        return undefined;
+    if (ctx.stack.filter((t) => t === msg.typeName).length >= 2)
+        return undefined;
+    return buildMessage(msg, ctx);
+}
+function singular(field, owner, rules, ctx, index, unboxed) {
+    // A list item or map value is generated at its own path, so items differ.
+    const at = index >= 0 ? { ...ctx, index, path: `${ctx.path}[${index}]` } : ctx;
+    const f = field;
+    const kind = field.fieldKind === "list"
+        ? field.listKind
+        : field.fieldKind === "map"
+            ? field.mapKind
+            : field.fieldKind;
+    switch (kind) {
+        case "scalar":
+            return scalarValue(f.scalar, field.name, owner, rules, at, f.longAsString ?? false);
+        case "enum":
+            return enumValue(f.enum, field.name, rules, at);
+        default: {
+            const msg = f.message;
+            const c = {
+                ...at,
+                path: `${at.path}.${field.name}`,
+                depth: ctx.depth + 1,
+                stack: [...ctx.stack, msg.typeName],
+            };
+            return messageAt(msg, field.name, owner, rules, c, unboxed);
+        }
+    }
+}
+function listCount(rules, ctx, name, fallbackMax) {
+    const rng = rngAt(ctx, `${name}#count`);
+    const r = rules?.repeated;
+    const min = r?.minItems ?? 0;
+    const max = r?.maxItems ?? Infinity;
+    // Past half the depth budget lists shrink to their minimum, so a deep tree
+    // of repeated messages stays a few hundred values rather than thousands.
+    if (ctx.depth * 2 > ctx.maxDepth)
+        return min;
+    const n = rng.int(3, fallbackMax);
+    return Math.max(min, Math.min(max, n));
+}
+function buildMessage(desc, ctx) {
+    knownSchemas.set(desc.typeName, desc);
+    const rng = rngAt(ctx, "#time");
+    // Newest first across a list: item i sits ~i·4 minutes before the anchor.
+    const baseTime = ctx.index >= 0
+        ? ctx.now - ctx.index * 240_000 - rng.int(0, 120_000)
+        : ctx.now - rng.int(0, 3_600_000);
+    const here = { ...ctx, baseTime };
+    const init = {};
+    for (const member of desc.members) {
+        if (member.kind === "oneof") {
+            const fields = member.fields;
+            if (fields.length === 0)
+                continue;
+            const pick = fields[rngAt(here, `${member.name}#case`).int(0, fields.length - 1)];
+            const value = singular(pick, desc, rulesOf(pick), here, -1, false);
+            if (value !== undefined)
+                init[member.localName] = { case: pick.localName, value };
+            continue;
+        }
+        const field = member;
+        const rules = rulesOf(field);
+        if (field.fieldKind === "list") {
+            const count = listCount(rules, here, field.name, 10);
+            const itemRules = rules?.repeated?.items;
+            const items = [];
+            for (let i = 0; i < count; i++) {
+                const v = singular(field, desc, itemRules, here, i, field.listKind === "message" && field.message.typeName === WKT_STRUCT);
+                if (v !== undefined)
+                    items.push(v);
+            }
+            init[field.localName] = items;
+        }
+        else if (field.fieldKind === "map") {
+            const r = rules?.map;
+            const mrng = rngAt(here, `${field.name}#pairs`);
+            let count = mrng.int(3, 5);
+            if (here.depth * 2 > here.maxDepth)
+                count = 0;
+            count = Math.max(r?.minPairs ?? 0, Math.min(r?.maxPairs ?? Infinity, count));
+            const out = {};
+            const stem = kebab(field.name).replace(/s$/, "") || "key";
+            for (let i = 0; i < count; i++) {
+                let key;
+                if (field.mapKey === ScalarType.STRING) {
+                    key = `${stem}-${i + 1}`;
+                    if (r?.keys?.str)
+                        key = applyStringRules(key, r.keys.str, mrng, i + 1);
+                }
+                else if (field.mapKey === ScalarType.BOOL) {
+                    if (i > 1)
+                        break;
+                    key = String(i === 0);
+                }
+                else {
+                    key = String(applyNumRules(i + 1, r?.keys?.num, mrng, false));
+                }
+                const at = { ...here, path: `${here.path}.${field.name}{${key}}` };
+                const v = field.mapKind === "scalar" && field.scalar === ScalarType.STRING
+                    ? applyStringRules(`value-${i + 1}`, r?.values?.str ?? {}, rngAt(at, "value"), i + 1)
+                    : singular(field, desc, r?.values, at, i, false);
+                if (v !== undefined)
+                    out[key] = v;
+            }
+            init[field.localName] = out;
+        }
+        else {
+            const v = singular(field, desc, rules, here, -1, field.fieldKind === "message");
+            if (v !== undefined)
+                init[field.localName] = v;
+        }
+    }
+    // A count beside the one list it counts reads as that list's length.
+    const lists = desc.fields.filter((f) => f.fieldKind === "list" && f.listKind === "message");
+    if (lists.length === 1) {
+        const total = desc.fields.find((f) => f.fieldKind === "scalar" &&
+            ["total_count", "total_size", "total", "total_items"].includes(f.name));
+        if (total && total.fieldKind === "scalar") {
+            const len = init[lists[0].localName].length;
+            init[total.localName] = coerceScalar(total.scalar, len, total.longAsString);
+        }
+    }
+    let message = create(desc, init);
+    const factory = ctx.factories.get(desc.typeName);
+    if (factory) {
+        const result = factory.build({
+            base: message,
+            index: ctx.index,
+            seed: `${ctx.seed}|${ctx.path}`,
+        });
+        message = isMessage(result)
+            ? result
+            : patch(message, result);
+    }
+    return message;
+}
+/**
+ * One deterministic, schema-valid message of `schema` — see the header for
+ * what each field becomes. Same options, same message.
+ */
+export function mockValue(schema, options = {}) {
+    return buildValue(schema, options);
+}
+/** mockValue, echoing `echo`'s scalar fields (the default handlers pass the request). */
+function buildValue(schema, options, echo) {
+    const now = anchorMs(options.now);
+    const ctx = {
+        seed: options.seed ?? schema.typeName,
+        path: "",
+        index: -1,
+        depth: 0,
+        maxDepth: options.maxDepth ?? 6,
+        now,
+        baseTime: now,
+        stack: [schema.typeName],
+        echo: echo ? collectEcho(echo.schema, echo.message) : new Map(),
+        factories: new Map((options.factories ?? []).map((f) => [f.schema.typeName, f])),
+    };
+    return buildMessage(schema, ctx);
+}
+function knownSchemaOf(message) {
+    return knownSchemas.get(message.$typeName);
+}
+function isPlainObject(v) {
+    return (typeof v === "object" &&
+        v !== null &&
+        !Array.isArray(v) &&
+        !(v instanceof Uint8Array) &&
+        !isMessage(v));
+}
+/**
+ * Deep-merge `changes` onto `base` and return a NEW message (base is not
+ * mutated). A nested message merges field by field; a list, a map, a oneof
+ * and a scalar are replaced. Partial list items are completed with zero
+ * values, as `create()` would.
+ *
+ *   const res = defaults.listTraces(req);
+ *   return patch(res, { traces: res.traces.slice(0, 2), red: { errorRate: 0.5 } });
+ */
+export function patch(base, changes) {
+    const desc = knownSchemaOf(base);
+    const merged = mergeInit(desc, base, changes);
+    return (desc ? rebuild(desc, merged) : merged);
+}
+/**
+ * create() over a merged init. The init still carries the base's $typeName,
+ * and create() returns anything that looks like a message untouched — which
+ * would leave a partial list item uncompleted — so the marker is dropped.
+ */
+function rebuild(desc, init) {
+    const { $typeName: _drop, ...fields } = init;
+    return create(desc, fields);
+}
+function mergeInit(desc, base, changes) {
+    const out = { ...base };
+    for (const [key, value] of Object.entries(changes)) {
+        if (value === undefined)
+            continue;
+        const field = desc?.fields.find((f) => f.localName === key);
+        const current = base[key];
+        if (isPlainObject(value) &&
+            isMessage(current) &&
+            (!field || (field.fieldKind === "message" && !field.oneof))) {
+            const nested = field?.fieldKind === "message" ? field.message : knownSchemaOf(current);
+            const m = mergeInit(nested, current, value);
+            out[key] = nested ? rebuild(nested, m) : m;
+        }
+        else {
+            out[key] = value;
+        }
+    }
+    return out;
+}
+/** Messages in a default stream. */
+const STREAM_LENGTH = 3;
+const defaultsCache = new WeakMap();
+function requestMessage(method, req) {
+    return isMessage(req)
+        ? req
+        : create(method.input, (req ?? {}));
+}
+/** The seed of one call: the method plus the request's wire bytes. */
+function callSeed(method, reqs) {
+    let digest = "";
+    for (const r of reqs) {
+        try {
+            digest += fnv1a(toBinary(method.input, r)).toString(16) + ".";
+        }
+        catch {
+            digest += "?.";
+        }
+    }
+    return `${method.parent.typeName}/${method.name}:${digest}`;
+}
+/**
+ * The default handlers of every RPC of `service`: a deterministic,
+ * schema-valid response per request (a 3-message stream for server and bidi
+ * streams). Generated `src/mocks/services/*_gen.ts` modules export one per
+ * service, and the mock transport serves them for any RPC that no scenario,
+ * passthrough or entity fixture answered.
+ *
+ * Without options the result is memoized per service, so every caller shares
+ * one object.
+ */
+export function serviceDefaults(service, options = {}) {
+    const plain = options.now === undefined &&
+        options.maxDepth === undefined &&
+        !options.factories?.length;
+    if (plain) {
+        const cached = defaultsCache.get(service);
+        if (cached)
+            return cached;
+    }
+    const out = {};
+    for (const method of service.methods) {
+        const streams = method.methodKind === "server_streaming" ||
+            method.methodKind === "bidi_streaming";
+        out[method.localName] = (req) => {
+            const reqs = (Array.isArray(req) ? req : [req]).map((r) => requestMessage(method, r));
+            const seed = callSeed(method, reqs);
+            const last = reqs[reqs.length - 1];
+            const echo = last ? { schema: method.input, message: last } : undefined;
+            const one = (s) => buildValue(method.output, { ...options, seed: s }, echo);
+            if (!streams)
+                return one(seed);
+            return Array.from({ length: STREAM_LENGTH }, (_, i) => one(`${seed}#${i}`));
+        };
+    }
+    Object.defineProperty(out, "$service", { value: service, enumerable: false });
+    const defaults = out;
+    if (plain)
+        defaultsCache.set(service, defaults);
+    return defaults;
+}
+/** True for what {@link serviceDefaults} returns — how the generated registry finds them. */
+export function isServiceDefaults(value) {
+    if (typeof value !== "object" || value === null)
+        return false;
+    const service = value.$service;
+    return (typeof service === "object" &&
+        service !== null &&
+        service.kind === "service");
+}
+/**
+ * Typed overrides for one service, as scenario handlers:
+ *
+ *   handlers: {
+ *     ...mockService(ObservabilityService, {
+ *       listTraces: (req, d) => patch(d.listTraces(req), { traces: [] }),
+ *     }),
+ *   }
+ *
+ * Each override receives the typed request and the service's defaults (built
+ * with `options.factories` when given). Only overridden RPCs get a handler —
+ * the rest fall through to the transport's own defaults — unless factories
+ * are given, in which case every RPC is answered with them.
+ */
+export function mockService(service, overrides, options = {}) {
+    const defaults = serviceDefaults(service, options);
+    const out = {};
+    const everyMethod = (options.factories?.length ?? 0) > 0;
+    for (const method of service.methods) {
+        const override = overrides[method.localName];
+        const fallback = defaults[method.localName];
+        if (!override && !everyMethod)
+            continue;
+        out[`${service.typeName}/${method.name}`] = override
+            ? (req) => override(requestMessage(method, req), defaults)
+            : (req) => fallback?.(req);
+    }
+    return out;
+}
+//# sourceMappingURL=mock-values.js.map