@neontechspace/fluxerly 1000.0.0-nightly.12

package/src/internal/counts.ts

@@ -0,0 +1,471 @@
+/**
+ * Fresh gateway counts: Nonce-correlated guild and channel member count requests across shards.
+ * Invariant: One logical request holds one admission slot across its shard fragments and releases every fragment on terminal
+ * failure or interruption. Provider omissions are result data, not a substitute for routing, readiness or transport failures,
+ * and no count is retained. Implements [SDK contracts: Delivery, requests and caches](/docs/SDK-CONTRACTS.md#delivery-requests-and-caches)
+ */
+import { randomUUID } from "node:crypto"
+import * as Effect from "effect/Effect"
+import {
+    CountOperationError,
+    type ChannelMemberCount,
+    type ChannelMemberCountsResult,
+    type CountOperation,
+    type CountOperationOptions,
+    type GuildCount,
+    type GuildCountsResult,
+} from "#sdk/counts"
+import { ClientClosedError } from "#sdk/errors"
+import { InputValidationFailure, inputValidationFailure, unsupportedKeyFailure } from "#sdk/input-validation"
+import { withDeadline } from "./effect-failures.js"
+import { GatewayRequestBudget } from "./gateway-requests.js"
+import type { InternalSubmission } from "./gateway/commands.js"
+import { gatewayIdentifier, nonNegativeInteger, record, snapshotArray } from "./decode/primitives.js"
+import { readCaller, suspendMarked } from "./defects.js"
+
+const defaultTimeoutMs = 30_000
+
+interface GatewaySender {
+    readonly guilds: (guildIds: readonly string[], nonce: string) => InternalSubmission
+    readonly channels: (guildId: string, channelIds: readonly string[], nonce: string) => InternalSubmission
+}
+
+interface RoutedGuilds {
+    readonly shardId: number
+    readonly guildIds: readonly string[]
+    readonly sender: GatewaySender
+}
+
+interface Request {
+    readonly operation: CountOperation
+    readonly ids: readonly string[]
+    readonly guildId?: string
+    readonly complete: (result: Effect.Effect<GuildCountsResult | ChannelMemberCountsResult, CountFailure>) => void
+    readonly release: () => void
+    readonly nonces: Set<string>
+    readonly withdraw: Set<() => void>
+    readonly counts: Map<string, GuildCount | ChannelMemberCount>
+    finished: boolean
+}
+
+interface Pending {
+    readonly request: Request
+    readonly shardId: number
+    readonly guildIds: readonly string[]
+    readonly channelIds?: readonly string[]
+}
+
+type CountFailure = CountOperationError | ClientClosedError
+type GatewayRoute = (guildId: string) => number | undefined
+
+/** Gateway-private bridge for fresh count frames. It retains only active reply correlations, never count observations */
+export interface CountGatewayOwner {
+    attach(
+        guilds: (guildIds: readonly string[], nonce: string) => InternalSubmission,
+        channels: (guildId: string, channelIds: readonly string[], nonce: string) => InternalSubmission,
+        shardId?: number,
+    ): void
+    detach(shardId?: number): void
+    receiveGuildCounts(value: unknown): void
+    receiveChannelMemberCounts(value: unknown): void
+}
+
+const shard = (value: unknown): value is number => nonNegativeInteger(value)
+
+function copyIdentifiers(
+    value: unknown,
+    path: "guildIds" | "channelIds",
+    maximum: number,
+): readonly string[] | InputValidationFailure {
+    if (!Array.isArray(value)) return inputValidationFailure(path, "type", "Must be a non-empty array of canonical IDs")
+    // Copy once and validate the copy, so the validated IDs are the ones requested
+    const ids = snapshotArray(value, maximum)
+    if (ids === undefined || ids.length < 1)
+        return inputValidationFailure(path, "length", `Must contain from 1 through ${maximum} IDs`)
+    if (!ids.every(gatewayIdentifier))
+        return inputValidationFailure(
+            path,
+            "format",
+            "Each ID must be a canonical positive decimal string no greater than 9223372036854775807",
+        )
+    return new Set(ids).size === ids.length
+        ? (ids as readonly string[])
+        : inputValidationFailure(path, "unique", "Must not contain duplicate IDs")
+}
+
+function timeout(value: unknown): number | InputValidationFailure {
+    if (value !== undefined && !record(value))
+        return inputValidationFailure("options", "type", "Must be an options object when supplied")
+    const unsupported =
+        value === undefined
+            ? undefined
+            : unsupportedKeyFailure(value, ["timeoutMs", "signal"], "options", "the operation options")
+    if (unsupported) return unsupported
+    const timeoutMs = value === undefined ? undefined : value.timeoutMs
+    const duration = timeoutMs === undefined ? defaultTimeoutMs : timeoutMs
+    if (typeof duration !== "number")
+        return inputValidationFailure("options.timeoutMs", "type", "Must be an integer number of milliseconds")
+    return Number.isSafeInteger(duration) && duration >= 1 && duration <= 2_147_483_647
+        ? duration
+        : inputValidationFailure(
+              "options.timeoutMs",
+              "range",
+              "Must be an integer from 1 through 2147483647 milliseconds",
+          )
+}
+
+function nonce(value: unknown): string | undefined {
+    return record(value) && typeof value.nonce === "string" ? value.nonce : undefined
+}
+
+function reply(value: unknown): { readonly counts: readonly unknown[] } | undefined {
+    return record(value) && Array.isArray(value.counts) ? { counts: value.counts } : undefined
+}
+
+function guildCounts(guildIds: readonly string[], value: unknown): readonly GuildCount[] | undefined {
+    const response = reply(value)
+    if (!response || response.counts.length > guildIds.length) return undefined
+    const counts = new Map<string, GuildCount>()
+    for (const entry of response.counts) {
+        if (
+            !record(entry) ||
+            !gatewayIdentifier(entry.guild_id) ||
+            !nonNegativeInteger(entry.member_count) ||
+            !nonNegativeInteger(entry.online_count) ||
+            Object.hasOwn(entry, "channel_id") ||
+            !guildIds.includes(entry.guild_id) ||
+            counts.has(entry.guild_id)
+        )
+            return undefined
+        counts.set(
+            entry.guild_id,
+            Object.freeze({
+                guildId: entry.guild_id,
+                memberCount: entry.member_count,
+                onlineCount: entry.online_count,
+            }),
+        )
+    }
+    return Object.freeze(guildIds.flatMap((guildId) => (counts.has(guildId) ? [counts.get(guildId)!] : [])))
+}
+
+function channelCounts(
+    guildId: string,
+    channelIds: readonly string[],
+    value: unknown,
+): readonly ChannelMemberCount[] | undefined {
+    const response = reply(value)
+    if (!response || response.counts.length > channelIds.length) return undefined
+    const counts = new Map<string, ChannelMemberCount>()
+    for (const entry of response.counts) {
+        if (
+            !record(entry) ||
+            entry.guild_id !== guildId ||
+            !gatewayIdentifier(entry.channel_id) ||
+            !nonNegativeInteger(entry.member_count) ||
+            !nonNegativeInteger(entry.online_count) ||
+            !channelIds.includes(entry.channel_id) ||
+            counts.has(entry.channel_id)
+        )
+            return undefined
+        counts.set(
+            entry.channel_id,
+            Object.freeze({
+                guildId,
+                channelId: entry.channel_id,
+                memberCount: entry.member_count,
+                onlineCount: entry.online_count,
+            }),
+        )
+    }
+    return Object.freeze(channelIds.flatMap((channelId) => (counts.has(channelId) ? [counts.get(channelId)!] : [])))
+}
+
+/**
+ * Owns nonce-correlated count requests across attached shards. Each logical request keeps one shared admission slot,
+ * even when its requested guilds need several gateway commands
+ */
+export class CountOwner implements CountGatewayOwner {
+    #senders = new Map<number, GatewaySender>()
+    #pending = new Map<string, Pending>()
+    #closed = false
+
+    constructor(
+        private readonly budget = new GatewayRequestBudget(),
+        private readonly routeGuild: GatewayRoute = () => 0,
+    ) {}
+
+    attach(
+        guilds: (guildIds: readonly string[], nonce: string) => InternalSubmission,
+        channels: (guildId: string, channelIds: readonly string[], nonce: string) => InternalSubmission,
+        shardId = 0,
+    ) {
+        if (!this.#closed && shard(shardId)) this.#senders.set(shardId, { guilds, channels })
+    }
+
+    detach(shardId?: number) {
+        if (shardId === undefined) {
+            this.#senders.clear()
+            this.#failPending(() => true, "connectionLost")
+            return
+        }
+        if (!shard(shardId)) return
+        this.#senders.delete(shardId)
+        this.#failPending((pending) => pending.shardId === shardId, "connectionLost")
+    }
+
+    close() {
+        if (this.#closed) return
+        this.#closed = true
+        this.#senders.clear()
+        this.#failPending(() => true, new ClientClosedError())
+    }
+
+    fetchGuilds(guildIds: readonly string[], options?: CountOperationOptions) {
+        return this.#request("guilds.fetchCounts", guildIds, undefined, options).pipe(
+            Effect.map((result) => result as GuildCountsResult),
+        )
+    }
+
+    fetchChannels(guildId: string, channelIds: readonly string[], options?: CountOperationOptions) {
+        return this.#request("channels.fetchMemberCounts", channelIds, guildId, options).pipe(
+            Effect.map((result) => result as ChannelMemberCountsResult),
+        )
+    }
+
+    receiveGuildCounts(value: unknown) {
+        const valueNonce = nonce(value)
+        if (!valueNonce) return
+        const pending = this.#pending.get(valueNonce)
+        if (!pending || pending.request.operation !== "guilds.fetchCounts") return
+        const counts = guildCounts(pending.guildIds, value)
+        if (!counts) {
+            this.#settle(
+                pending.request,
+                Effect.fail(new CountOperationError({ operation: pending.request.operation, reason: "response" })),
+            )
+            return
+        }
+        this.#complete(valueNonce, counts)
+    }
+
+    receiveChannelMemberCounts(value: unknown) {
+        const valueNonce = nonce(value)
+        if (!valueNonce) return
+        const pending = this.#pending.get(valueNonce)
+        if (!pending || pending.request.operation !== "channels.fetchMemberCounts" || !pending.channelIds) return
+        const counts = channelCounts(pending.request.guildId!, pending.channelIds, value)
+        if (!counts) {
+            this.#settle(
+                pending.request,
+                Effect.fail(new CountOperationError({ operation: pending.request.operation, reason: "response" })),
+            )
+            return
+        }
+        this.#complete(valueNonce, counts)
+    }
+
+    #request(
+        operation: CountOperation,
+        ids: readonly string[],
+        guildId: string | undefined,
+        options?: CountOperationOptions,
+    ) {
+        // Only reading the caller IDs and options is marked, so a throw there is an application fault
+        return suspendMarked(() => {
+            if (this.#closed) return Effect.fail(new ClientClosedError())
+            const guildRequest = operation === "guilds.fetchCounts"
+            const copiedIds = readCaller(() =>
+                copyIdentifiers(ids, guildRequest ? "guildIds" : "channelIds", guildRequest ? 100 : 25),
+            )
+            if (copiedIds instanceof InputValidationFailure)
+                return Effect.fail(
+                    new CountOperationError({ operation, reason: "input", inputValidation: copiedIds.detail }),
+                )
+            const duration = readCaller(() => timeout(options))
+            if (duration instanceof InputValidationFailure)
+                return Effect.fail(
+                    new CountOperationError({ operation, reason: "input", inputValidation: duration.detail }),
+                )
+            const channelGuildId = guildRequest ? undefined : gatewayIdentifier(guildId) ? guildId : undefined
+            if (!guildRequest && channelGuildId === undefined)
+                return Effect.fail(
+                    new CountOperationError({
+                        operation,
+                        reason: "input",
+                        inputValidation: inputValidationFailure(
+                            "guildId",
+                            "format",
+                            "Must be a canonical positive decimal string no greater than 9223372036854775807",
+                        ).detail,
+                    }),
+                )
+            const routed = guildRequest
+                ? this.#routeGuilds(copiedIds)
+                : this.#routeGuilds(Object.freeze([channelGuildId!]))
+            if (!routed) return Effect.fail(new CountOperationError({ operation, reason: "notConnected" }))
+            const request = Effect.callback<GuildCountsResult | ChannelMemberCountsResult, CountFailure>((complete) => {
+                const release = this.budget.acquire()
+                if (!release) {
+                    complete(Effect.fail(new CountOperationError({ operation, reason: "busy" })))
+                    return
+                }
+                const pendingRequest: Request = {
+                    operation,
+                    ids: copiedIds,
+                    ...(guildRequest ? {} : { guildId: channelGuildId! }),
+                    complete,
+                    release,
+                    nonces: new Set(),
+                    withdraw: new Set(),
+                    counts: new Map(),
+                    finished: false,
+                }
+                try {
+                    const fragments = routed.map(({ shardId, guildIds, sender }) => ({
+                        nonce: randomUUID(),
+                        pending: {
+                            request: pendingRequest,
+                            shardId,
+                            guildIds,
+                            ...(guildRequest ? {} : { channelIds: copiedIds }),
+                        },
+                        sender,
+                    }))
+                    for (const { nonce, pending } of fragments) {
+                        this.#pending.set(nonce, pending)
+                        pendingRequest.nonces.add(nonce)
+                    }
+                    for (const { nonce, pending, sender } of fragments) {
+                        if (pendingRequest.finished) break
+                        const submission = guildRequest
+                            ? sender.guilds(pending.guildIds, nonce)
+                            : sender.channels(channelGuildId!, copiedIds, nonce)
+                        if (typeof submission === "string") {
+                            this.#settle(
+                                pendingRequest,
+                                Effect.fail(
+                                    new CountOperationError({
+                                        operation,
+                                        reason: submission === "busy" ? "busy" : "connectionLost",
+                                    }),
+                                ),
+                            )
+                            break
+                        }
+                        if (submission) pendingRequest.withdraw.add(submission.cancel)
+                    }
+                } catch (defect) {
+                    this.#cancel(pendingRequest)
+                    throw defect
+                }
+                return Effect.sync(() => this.#cancel(pendingRequest))
+            }).pipe(withDeadline(duration, () => new CountOperationError({ operation, reason: "timeout" })))
+            return request
+        })
+    }
+
+    #routeGuilds(guildIds: readonly string[]): readonly RoutedGuilds[] | undefined {
+        const routed = new Map<number, string[]>()
+        for (const guildId of guildIds) {
+            const shardId = this.routeGuild(guildId)
+            if (!shard(shardId)) return undefined
+            const ids = routed.get(shardId)
+            if (ids) ids.push(guildId)
+            else routed.set(shardId, [guildId])
+        }
+        const groups: RoutedGuilds[] = []
+        for (const [shardId, guilds] of routed) {
+            const sender = this.#senders.get(shardId)
+            if (!sender) return undefined
+            groups.push({ shardId, guildIds: Object.freeze(guilds), sender })
+        }
+        return Object.freeze(groups)
+    }
+
+    #complete(nonce: string, counts: readonly (GuildCount | ChannelMemberCount)[]) {
+        const pending = this.#pending.get(nonce)
+        if (!pending || pending.request.finished) return
+        const request = pending.request
+        for (const count of counts) {
+            const id =
+                request.operation === "guilds.fetchCounts" ? count.guildId : (count as ChannelMemberCount).channelId
+            if (request.counts.has(id)) {
+                this.#settle(
+                    request,
+                    Effect.fail(new CountOperationError({ operation: request.operation, reason: "response" })),
+                )
+                return
+            }
+            request.counts.set(id, count)
+        }
+        this.#pending.delete(nonce)
+        request.nonces.delete(nonce)
+        if (request.nonces.size !== 0) return
+        const result =
+            request.operation === "guilds.fetchCounts" ? this.#guildResult(request) : this.#channelResult(request)
+        this.#settle(request, Effect.succeed(result))
+    }
+
+    #guildResult(request: Request): GuildCountsResult {
+        const counts = Object.freeze(
+            request.ids.flatMap((guildId) => {
+                const count = request.counts.get(guildId)
+                return count ? [count as GuildCount] : []
+            }),
+        )
+        return Object.freeze({
+            counts,
+            omittedGuildIds: Object.freeze(request.ids.filter((guildId) => !request.counts.has(guildId))),
+        })
+    }
+
+    #channelResult(request: Request): ChannelMemberCountsResult {
+        const counts = Object.freeze(
+            request.ids.flatMap((channelId) => {
+                const count = request.counts.get(channelId)
+                return count ? [count as ChannelMemberCount] : []
+            }),
+        )
+        return Object.freeze({
+            counts,
+            omittedChannelIds: Object.freeze(request.ids.filter((channelId) => !request.counts.has(channelId))),
+        })
+    }
+
+    #failPending(predicate: (pending: Pending) => boolean, failure: CountOperationError["reason"] | ClientClosedError) {
+        const requests = new Set<Request>()
+        for (const pending of this.#pending.values()) if (predicate(pending)) requests.add(pending.request)
+        for (const request of requests) {
+            this.#settle(
+                request,
+                Effect.fail(
+                    failure instanceof ClientClosedError
+                        ? failure
+                        : new CountOperationError({ operation: request.operation, reason: failure }),
+                ),
+            )
+        }
+    }
+
+    #settle(request: Request, result: Effect.Effect<GuildCountsResult | ChannelMemberCountsResult, CountFailure>) {
+        if (request.finished) return
+        request.finished = true
+        for (const nonce of request.nonces) this.#pending.delete(nonce)
+        request.nonces.clear()
+        for (const withdraw of request.withdraw) withdraw()
+        request.withdraw.clear()
+        request.release()
+        request.complete(result)
+    }
+
+    #cancel(request: Request) {
+        if (request.finished) return
+        request.finished = true
+        for (const nonce of request.nonces) this.#pending.delete(nonce)
+        request.nonces.clear()
+        for (const withdraw of request.withdraw) withdraw()
+        request.withdraw.clear()
+        request.release()
+    }
+}

package/src/internal/decode/primitives.ts

@@ -0,0 +1,67 @@
+/**
+ * Shared primitive decoders for provider data and local input: Records, decimal identifiers and integer ranges.
+ * Invariant: Each predicate reads only the value it is given, never coerces, and accepts exactly one documented range,
+ * so a failing field path traced through a decoder names the field these predicates rejected.
+ * Implements [SDK contracts: Validation requirements](/docs/SDK-CONTRACTS.md#validation-requirements)
+ */
+
+const int32Minimum = -2_147_483_648
+const int32Maximum = 2_147_483_647
+
+/** A plain object, excluding null and arrays */
+export const record = (value: unknown): value is Record<string, unknown> =>
+    typeof value === "object" && value !== null && !Array.isArray(value)
+
+/** A decimal snowflake string without leading zeros. "0" is accepted */
+export const identifier = (value: unknown): value is string =>
+    typeof value === "string" && /^(0|[1-9][0-9]*)$/.test(value)
+
+/** A canonical positive snowflake accepted by gateway commands, no greater than the signed int64 maximum */
+export const gatewayIdentifier = (value: unknown): value is string =>
+    typeof value === "string" &&
+    value.length <= 19 &&
+    identifier(value) &&
+    value !== "0" &&
+    (value.length < 19 || value <= "9223372036854775807")
+
+/** A safe integer from minimum through maximum inclusive */
+export const integerInRange = (value: unknown, minimum: number, maximum: number): value is number =>
+    typeof value === "number" && Number.isSafeInteger(value) && value >= minimum && value <= maximum
+
+/** Any safe integer, including negative values */
+export const safeInteger = (value: unknown): value is number => typeof value === "number" && Number.isSafeInteger(value)
+
+/** A safe integer from zero through maximum, which defaults to the largest safe integer */
+export const nonNegativeInteger = (value: unknown, maximum = Number.MAX_SAFE_INTEGER): value is number =>
+    integerInRange(value, 0, maximum)
+
+/** A signed 32-bit integer */
+export const int32 = (value: unknown): value is number => integerInRange(value, int32Minimum, int32Maximum)
+
+/** A non-negative signed 32-bit integer, the provider's count and limit range */
+export const count = (value: unknown): value is number => integerInRange(value, 0, int32Maximum)
+
+/**
+ * Read named fields of a caller record at most once each, in first-use order, and return the kept value on later reads.
+ * Validation and encoding then use the same value even when a getter or proxy would return another
+ */
+export function fieldsOnce(value: Record<string, unknown>): (key: string) => unknown {
+    const values = new Map<string, unknown>()
+    return (key) => {
+        if (values.has(key)) return values.get(key)
+        const item = value[key]
+        values.set(key, item)
+        return item
+    }
+}
+
+/** A frozen copy of an array with at most maximum items, read once by index so later mutation cannot change it */
+export function snapshotArray(value: unknown, maximum: number): readonly unknown[] | undefined {
+    if (!Array.isArray(value)) return undefined
+    const length = value.length
+    if (length > maximum) return undefined
+    // oxlint-disable-next-line unicorn/no-new-array -- preallocates the counted length once, and the loop below assigns every index
+    const items = new Array<unknown>(length)
+    for (let index = 0; index < length; index++) items[index] = value[index]
+    return Object.freeze(items)
+}

package/src/internal/decode/timestamp.ts

@@ -0,0 +1,29 @@
+/**
+ * The SDK's one ISO-8601 timestamp grammar for provider data and timestamp inputs.
+ * Invariant: A timestamp has a calendar date, a T separator, hours, minutes and seconds, an optional fraction of any
+ * length and a Z or ±hh:mm offset, names a real calendar day, and is kept exactly as received or supplied.
+ * Implements [SDK contracts: Validation requirements](/docs/SDK-CONTRACTS.md#validation-requirements)
+ */
+
+const monthDays = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31] as const
+const isoTimestamp = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/
+
+/** Reject calendar overflow that Date.parse normalizes, such as April 31, and values Date.parse cannot read */
+export function validCalendarTimestamp(value: string): boolean {
+    const match = /^(\d{4})-(\d{2})-(\d{2})T/.exec(value)
+    if (match === null) return false
+    const year = Number(match[1])
+    const month = Number(match[2])
+    const day = Number(match[3])
+    if (month < 1 || month > 12 || day < 1) return false
+    const leap = year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0)
+    const maximum = month === 2 && leap ? 29 : monthDays[month - 1]!
+    return day <= maximum && Number.isFinite(Date.parse(value))
+}
+
+/** An ISO-8601 timestamp with seconds, any fraction and a Z or ±hh:mm offset, on a real calendar day */
+export const timestamp = (value: unknown): value is string =>
+    typeof value === "string" && isoTimestamp.test(value) && validCalendarTimestamp(value)
+
+/** A timestamp or null */
+export const nullableTimestamp = (value: unknown): value is string | null => value === null || timestamp(value)

package/src/internal/decode/trace.ts

@@ -0,0 +1,65 @@
+/**
+ * Field-path tracing for rejected provider payloads, used by the malformed-dispatch record.
+ * Invariant: Tracing re-runs a pure decoder over a structured clone, records only property names and array indexes,
+ * and never exposes or retains payload values.
+ * Implements [SDK contracts: Logging](/docs/SDK-CONTRACTS.md#logging)
+ */
+/** The named check a decoder rejected its value on, set by rejectCheck while failingFieldPath re-runs the decoder */
+let rejectedCheck: string | undefined
+
+/** Reject a decoded value on a check across items or fields, such as page order, whose last read field is valid.
+ * Return its result from a decoder in place of undefined, so the failure names the check instead of that field
+ */
+export function rejectCheck(check: string): undefined {
+    rejectedCheck = check
+    return undefined
+}
+
+/** Re-run a pure decoder over a tracing view of a rejected payload and return the last field path it read, or the
+ * check it named through rejectCheck.
+ * Decoders read fields in order and stop at the first invalid one, so the last read path names the failing field.
+ * Only property names and array indexes are recorded, never values. Returns undefined when nothing was read
+ */
+export function failingFieldPath(decode: (value: unknown) => unknown, value: unknown): string | undefined {
+    if (typeof value !== "object" || value === null) return undefined
+    let last: readonly (string | number)[] | undefined
+    const proxies = new WeakMap<object, object>()
+    const wrap = (target: unknown, path: readonly (string | number)[]): unknown => {
+        if (typeof target !== "object" || target === null) return target
+        const cached = proxies.get(target)
+        if (cached) return cached
+        const segment = (key: string | symbol) =>
+            typeof key === "symbol" ? undefined : Array.isArray(target) && /^\d+$/.test(key) ? Number(key) : key
+        const proxy = new Proxy(target, {
+            get(object, key, receiver) {
+                const name = segment(key)
+                const result: unknown = Reflect.get(object, key, receiver)
+                if (name === undefined || (Array.isArray(object) && name === "length") || typeof result === "function")
+                    return result
+                last = [...path, name]
+                return wrap(result, last)
+            },
+            has(object, key) {
+                const name = segment(key)
+                if (name !== undefined) last = [...path, name]
+                return Reflect.has(object, key)
+            },
+            getOwnPropertyDescriptor(object, key) {
+                const name = segment(key)
+                if (name !== undefined) last = [...path, name]
+                return Reflect.getOwnPropertyDescriptor(object, key)
+            },
+        })
+        proxies.set(target, proxy)
+        return proxy
+    }
+    rejectedCheck = undefined
+    try {
+        decode(wrap(structuredClone(value), []))
+    } catch {
+        // allow-silent: A decoder that throws on the tracing view still leaves the last read path
+    }
+    const check = rejectedCheck
+    rejectedCheck = undefined
+    return check ?? last?.map(String).join(".")
+}