[{"_1":2,"_3":-5,"_4":-5},"loaderData",{"_5":6,"_7":8,"_9":10,"_11":12},"actionData","errors","root",{"_228":-5,"_231":232,"_233":234},"routes/shell",{"_41":42,"_227":-5,"_228":-5,"_229":230},"routes/repo",{"_34":-7,"_35":36,"_37":38,"_39":40,"_41":42,"_43":32,"_44":32,"_45":32,"_46":32,"_47":32,"_48":32,"_49":50,"_51":50,"_52":32,"_53":-7,"_54":-7,"_55":56,"_57":58,"_59":60,"_61":-5,"_62":63,"_64":65,"_66":67,"_68":69},"routes/repo.blob",{"_13":14,"_15":16,"_17":18,"_19":20,"_21":22,"_23":24,"_25":-5,"_26":27,"_28":29,"_29":30,"_31":32,"_33":14},"ref","main","path","packages/editor/src/provider.ts","oid","64bf96026fdb9c6bec7350baa15c574c3ef2f6e5","size",19675,"commit","2182c95de44a8f63fd86af1c5874ae0ca298f807","mounts",[],"source","plain",{"_13":14,"_15":16},"kind","text","/**\n * A Yjs provider over the room's connection.\n *\n * Lexical's collaboration plugin expects a provider that owns a transport. The\n * room already has one, so this adapts it rather than opening a second socket:\n * one connection, one gate, one reconnect policy.\n *\n * The server is authoritative. This never bootstraps a document — it syncs to\n * what the server already has, which is what stops two clients opening an\n * empty plan from both seeding it.\n */\n\nimport { applyAwarenessUpdate, Awareness, encodeAwarenessUpdate } from \"y-protocols/awareness\";\nimport * as Y from \"yjs\";\n\nimport type { Plan } from \"@chopin/protocol\";\nimport type { Provider } from \"@lexical/yjs\";\nimport type { Transport } from \"./transport\";\n\ntype Listener = (value: T) => void;\n\ntype Events = {\n\tsync: boolean;\n\tstatus: { status: string; message?: string };\n\tupdate: unknown;\n\treload: Y.Doc;\n};\n\n/** Yjs updates are binary; the wire speaks JSON. */\nfunction encode(value: Uint8Array): string {\n\tlet binary = \"\";\n\tfor (let byte of value) binary += String.fromCharCode(byte);\n\treturn btoa(binary);\n}\n\nfunction decode(value: string): Uint8Array {\n\tlet binary = atob(value);\n\tlet out = new Uint8Array(binary.length);\n\tfor (let i = 0; i < binary.length; i++) out[i] = binary.charCodeAt(i);\n\treturn out;\n}\n\nexport type PlanProviderOptions = {\n\twire: Transport;\n\tdoc: Y.Doc;\n\t/**\n\t * Told when the server rotates the epoch and local state must be discarded.\n\t *\n\t * `lost` is true when edits the server never acknowledged went with it, so\n\t * the person can be told rather than finding out later.\n\t */\n\tonReset?: (reason: Plan.Reset[\"reason\"], lost: boolean) => void;\n\t/**\n\t * Authoritative snapshot of which prose each decision and comment names.\n\t *\n\t * The whole snapshot: these relationships arrive together because\n\t * they describe the same document at the same moment, and splitting them\n\t * into separate callbacks would let a consumer act on one while holding a\n\t * stale copy of another.\n\t */\n\tonAnchors?: (\n\t\tsnapshot: {\n\t\t\twidgets: Plan.WidgetAnchors[];\n\t\t\tthreads: Plan.ThreadAnchors[];\n\t\t\tprose: Plan.ProseAnchors[];\n\t\t},\n\t) => void;\n\t/**\n\t * What the agent just did, to be marked in the prose.\n\t *\n\t * Unlike the anchors, this is not part of opening a document: it says what\n\t * changed a moment ago, which is only true for a moment. Somebody arriving\n\t * afterwards is reading the plan, not watching it being written.\n\t */\n\tonChanges?: (changes: Plan.Change[]) => void;\n\t/** Called just before a peer's update is applied, with whether an agent wrote it. */\n\tonRemoteUpdate?: (agent: boolean) => void;\n};\n\n/**\n * Bounds the unacknowledged outbox.\n *\n * Past either of these the connection has been down long enough that holding\n * every keystroke separately is wasteful. Yjs updates merge losslessly, so the\n * backlog is collapsed into one rather than trimmed: nothing is dropped, and\n * what is eventually replayed is the same document either way.\n */\nconst MAX_OUTBOX_BYTES = 2 * 1024 * 1024;\nconst MAX_OUTBOX_ITEMS = 1_000;\n\n/**\n * Pacing for outgoing updates.\n *\n * The server takes at most 200 updates a second from one socket and drops the\n * rest without replying. Typing faster than that (a script, a held key with a\n * fast repeat) lost the excess, and Yjs then held back every later update from\n * this client until the missing one arrived, so the rest of the session never\n * reached anyone. Updates made within one interval go out merged, which keeps\n * this client well under the limit, and anything still unacknowledged after a\n * while is sent again in case it was dropped anyway.\n */\nconst SEND_MS = 10;\n/**\n * Resends back off from this, doubling up to `MAX_RESEND_MS`, so a server that\n * is slow to commit is not also asked to take every backlog again.\n */\nconst RESEND_MS = 2_000;\nconst MAX_RESEND_MS = 30_000;\n/**\n * An update sent this many times without an acknowledgement is left for the\n * next open to replay. Something other than a dropped frame is refusing it.\n */\nconst MAX_SENDS = 5;\n/** Merged updates stay far below the server's per-update limit. */\nconst MERGE_BYTES = 64 * 1024;\n\nexport class PlanProvider implements Provider {\n\t/**\n\t * y-protocols' `Awareness` is structurally what Lexical wants, but its state\n\t * is typed as an open record while Lexical narrows it to its own cursor\n\t * shape. The runtime contract is identical.\n\t */\n\treadonly awareness: Awareness & Provider[\"awareness\"];\n\n\treadonly #wire: Transport;\n\treadonly #doc: Y.Doc;\n\treadonly #options: PlanProviderOptions;\n\treadonly #listeners = new Map>>();\n\treadonly #offs: Array<() => void> = [];\n\n\t/** Updates sent but not yet acknowledged, replayed after a reconnect. */\n\treadonly #outbox = new Map();\n\t#outboxBytes = 0;\n\t/** Outbox entries waiting for the current send interval to end. */\n\treadonly #unsent = new Set();\n\t/** Outbox entries already outstanding when the resend timer last fired. */\n\t#overdue = new Set();\n\t/** How often each outbox entry has been sent since the last open. */\n\treadonly #sends = new Map();\n\t#resendDelay = RESEND_MS;\n\t#pacing: ReturnType | undefined;\n\t#resending: ReturnType | undefined;\n\n\t#epoch: string | undefined;\n\t#synced = false;\n\t#connected = false;\n\t/** An open is in flight, so a second `resume` would ask for it twice. */\n\t#opening = false;\n\t#counter = 0;\n\t#generation = 0;\n\n\tconstructor(options: PlanProviderOptions) {\n\t\tthis.#options = options;\n\t\tthis.#wire = options.wire;\n\t\tthis.#doc = options.doc;\n\t\tthis.awareness = new Awareness(options.doc) as PlanProvider[\"awareness\"];\n\t}\n\n\tget epoch(): string | undefined {\n\t\treturn this.#epoch;\n\t}\n\n\t/** True while the backlog has grown past the point of holding it item by item. */\n\tget saturated(): boolean {\n\t\treturn this.#outboxBytes >= MAX_OUTBOX_BYTES || this.#outbox.size >= MAX_OUTBOX_ITEMS;\n\t}\n\n\t/**\n\t * Collapse the backlog into a single update.\n\t *\n\t * Only reachable while disconnected, since an acknowledgement removes an\n\t * entry. The merged update carries a fresh id: the ones it replaces will\n\t * never be acknowledged, because they were never received.\n\t */\n\t#coalesce(): void {\n\t\tthis.#merge([...this.#outbox.keys()]);\n\t}\n\n\t/**\n\t * Replace outbox entries with as few merged ones as stay under\n\t * `MERGE_BYTES`, and return the ids that now hold them.\n\t *\n\t * A merged entry carries a fresh id: acknowledgements for the ones it\n\t * replaces may still arrive and are ignored, and the merged one is only\n\t * settled by its own.\n\t */\n\t#merge(ids: string[]): string[] {\n\t\tlet groups: string[][] = [];\n\t\tlet size = 0;\n\t\tfor (let id of ids) {\n\t\t\tlet bytes = this.#outbox.get(id)?.byteLength;\n\t\t\tif (bytes === undefined) continue;\n\t\t\tlet group = groups.at(-1);\n\t\t\tif (!group || size + bytes > MERGE_BYTES) {\n\t\t\t\tgroups.push([id]);\n\t\t\t\tsize = bytes;\n\t\t\t} else {\n\t\t\t\tgroup.push(id);\n\t\t\t\tsize += bytes;\n\t\t\t}\n\t\t}\n\n\t\treturn groups.map(group => {\n\t\t\tif (group.length === 1) return group[0]!;\n\t\t\tlet merged = Y.mergeUpdates(group.map(id => this.#outbox.get(id)!));\n\t\t\tlet id = `merged-${this.#counter++}`;\n\t\t\tlet unsent = false;\n\t\t\tlet sends = 0;\n\t\t\tfor (let part of group) {\n\t\t\t\tthis.#outboxBytes -= this.#outbox.get(part)!.byteLength;\n\t\t\t\tthis.#outbox.delete(part);\n\t\t\t\tif (this.#unsent.delete(part)) unsent = true;\n\t\t\t\tthis.#overdue.delete(part);\n\t\t\t\tsends = Math.max(sends, this.#sends.get(part) ?? 0);\n\t\t\t\tthis.#sends.delete(part);\n\t\t\t}\n\t\t\tthis.#outbox.set(id, merged);\n\t\t\tthis.#outboxBytes += merged.byteLength;\n\t\t\tif (unsent) this.#unsent.add(id);\n\t\t\tif (sends > 0) this.#sends.set(id, sends);\n\t\t\treturn id;\n\t\t});\n\t}\n\n\t// -- provider surface ----------------------------------------------------\n\n\ton(type: K, cb: Listener): void {\n\t\tlet set = this.#listeners.get(type) ?? new Set();\n\t\tset.add(cb as Listener);\n\t\tthis.#listeners.set(type, set);\n\t}\n\n\toff(type: K, cb: Listener): void {\n\t\tthis.#listeners.get(type)?.delete(cb as Listener);\n\t}\n\n\t#emit(type: K, value: Events[K]): void {\n\t\tfor (let listener of this.#listeners.get(type) ?? []) {\n\t\t\t(listener as Listener)(value);\n\t\t}\n\t}\n\n\t/**\n\t * Open the document, or bring it back up to date.\n\t *\n\t * Safe to call whenever the transport says it can carry a request: on the\n\t * first connection, and again after every reconnect.\n\t *\n\t * The provider used to open exactly once, when the editor mounted, and a\n\t * transport comes up on its own schedule — so if the socket had not\n\t * finished its handshake by then the plan never opened at all, and nothing\n\t * tried again. The same gap swallowed a reconnect: `#open` is the only\n\t * thing that asks for the updates missed while the connection was down and\n\t * the only thing that replays the outbox, so without it the editor came\n\t * back unlocked and quietly short of everybody else's edits.\n\t *\n\t * `#open` handles both cases already. It sends the epoch and state vector,\n\t * so a resume fetches only the difference rather than the whole document.\n\t */\n\tasync resume(): Promise {\n\t\t// Not attached yet, already opening, or the transport cannot carry it —\n\t\t// in the last case it will say when it can, and this runs again.\n\t\tif (!this.#connected || this.#opening) return;\n\t\tif (this.#wire.connected === false) return;\n\n\t\tthis.#opening = true;\n\t\ttry {\n\t\t\tawait this.#open(this.#generation);\n\t\t} finally {\n\t\t\tthis.#opening = false;\n\t\t}\n\t}\n\n\tasync connect(): Promise {\n\t\tif (this.#connected) return;\n\t\tthis.#connected = true;\n\t\tthis.#generation++;\n\n\t\t// Subscribe before opening: an update published between the reply being\n\t\t// built and this handler being attached would otherwise be lost.\n\t\tthis.#offs.push(\n\t\t\tthis.#wire.on(\"plan:update\", event => this.#remote(event)),\n\t\t\tthis.#wire.on(\"plan:ack\", event => this.#settle(event.id)),\n\t\t\tthis.#wire.on(\"plan:awareness\", event => this.#presence(event)),\n\t\t\tthis.#wire.on(\"plan:reset\", event => this.#reset(event)),\n\t\t\t// Refused outright rather than dropped: repeating it changes nothing.\n\t\t\tthis.#wire.on<{ message?: string }>(\"session:error\", event => {\n\t\t\t\tif (event.message === \"implementation is active\") this.#park();\n\t\t\t}),\n\t\t\tthis.#wire.on(\"plan:changes\", event => {\n\t\t\t\tif (event.epoch === this.#epoch) this.#options.onChanges?.(event.changes);\n\t\t\t}),\n\t\t\tthis.#wire.on(\"plan:anchors\", event => {\n\t\t\t\tif (event.epoch === this.#epoch) {\n\t\t\t\t\tthis.#anchors({\n\t\t\t\t\t\twidgets: event.widgets,\n\t\t\t\t\t\tthreads: event.threads,\n\t\t\t\t\t\tprose: event.prose ?? [],\n\t\t\t\t\t});\n\t\t\t\t}\n\t\t\t}),\n\t\t);\n\n\t\tthis.#doc.on(\"update\", this.#local);\n\t\tthis.awareness.on(\"update\", this.#announce);\n\n\t\tawait this.resume();\n\t}\n\n\t/**\n\t * Say the document could not be opened.\n\t *\n\t * Called by whoever started the connection, because it is the only place\n\t * the rejection can be seen: `connect` is fired and forgotten, so a throw\n\t * on the way in otherwise leaves the editor locked and the chrome claiming\n\t * it is still loading.\n\t */\n\tfail(message: string): void {\n\t\tthis.#emit(\"status\", { status: \"failed\", message });\n\t}\n\n\tdisconnect(): void {\n\t\tthis.#connected = false;\n\t\tthis.#generation++;\n\t\tthis.#synced = false;\n\n\t\tfor (let off of this.#offs) off();\n\t\tthis.#offs.length = 0;\n\n\t\tthis.#doc.off(\"update\", this.#local);\n\t\tthis.awareness.off(\"update\", this.#announce);\n\t\tthis.awareness.destroy();\n\t\tthis.#stopTimers();\n\n\t\tthis.#wire.send(\"plan:close\", {});\n\t\tthis.#emit(\"status\", { status: \"disconnected\" });\n\t\tthis.#emit(\"sync\", false);\n\t}\n\n\t// -- synchronisation -----------------------------------------------------\n\n\t/**\n\t * Join the document.\n\t *\n\t * Resuming the same epoch sends a state vector so the server replies with\n\t * only the difference; a rotated epoch means local state is meaningless and\n\t * the whole document is fetched instead.\n\t */\n\tasync #open(generation: number): Promise {\n\t\tlet resume = this.#epoch\n\t\t\t? { epoch: this.#epoch, vector: encode(Y.encodeStateVector(this.#doc)) }\n\t\t\t: {};\n\n\t\tlet reply = await this.#wire.ask(\"plan:open\", { ...resume });\n\t\tif (!this.#connected || generation !== this.#generation) return;\n\n\t\t/*\n\t\t * The epoch rotated while this client was away, so it never heard the\n\t\t * reset. Its document and outbox describe a history that no longer\n\t\t * exists: merging the new state into it keeps edits nobody else has,\n\t\t * and every later edit is acknowledged but never applies, because it\n\t\t * builds on them. Rebuild from the server instead, as a reset would.\n\t\t */\n\t\tif (this.#epoch !== undefined && this.#epoch !== reply.epoch) {\n\t\t\tthis.#discard(\"replaced\");\n\t\t\treturn;\n\t\t}\n\t\tthis.#epoch = reply.epoch;\n\n\t\t// Server state never originates locally, so it must not be echoed back.\n\t\tY.applyUpdate(this.#doc, decode(reply.update), this);\n\n\t\tif (reply.awareness) {\n\t\t\tapplyAwarenessUpdate(this.awareness, decode(reply.awareness), this);\n\t\t}\n\n\t\tthis.#replay();\n\n\t\tthis.#synced = true;\n\t\tthis.#emit(\"status\", { status: \"connected\" });\n\t\tthis.#emit(\"sync\", true);\n\n\t\t// After the document is open, never before it.\n\t\t//\n\t\t// Anchors decorate the prose; they are not a precondition for having\n\t\t// it. Resolving them here used to sit between applying the update and\n\t\t// declaring the document synced, so anything that threw while working\n\t\t// out where a decision pointed skipped the emit — and the editor stayed\n\t\t// locked for the rest of the session, with the rejection swallowed by\n\t\t// the `void connect()` that started it.\n\t\tthis.#anchors({ widgets: reply.anchors, threads: reply.threads, prose: reply.prose ?? [] });\n\t}\n\n\t/**\n\t * Hand the relationship snapshot on, whatever it does with it.\n\t *\n\t * Guarded because the alternative is a highlight failing to paint and\n\t * taking the document with it. A reader losing an outline is a nuisance; a\n\t * room that cannot be edited is not.\n\t */\n\t#anchors(snapshot: {\n\t\twidgets: Plan.WidgetAnchors[];\n\t\tthreads: Plan.ThreadAnchors[];\n\t\tprose: Plan.ProseAnchors[];\n\t}): void {\n\t\ttry {\n\t\t\tthis.#options.onAnchors?.(snapshot);\n\t\t} catch (err) {\n\t\t\tconsole.error(\"[plan] could not resolve where decisions point:\", err);\n\t\t}\n\t}\n\n\t/**\n\t * Resend updates whose acknowledgement never arrived.\n\t *\n\t * Yjs updates are idempotent, so a duplicate is harmless — losing one is\n\t * not, which is why the outbox survives a reconnect on the same epoch.\n\t * Merged first, so a long backlog does not arrive faster than the server\n\t * accepts it.\n\t */\n\t#replay(): void {\n\t\tthis.#unsent.clear();\n\t\tthis.#sends.clear();\n\t\tthis.#resendDelay = RESEND_MS;\n\t\tfor (let id of this.#merge([...this.#outbox.keys()])) this.#send(id);\n\t}\n\n\t#local = (update: Uint8Array, origin: unknown): void => {\n\t\t// Anything the server or the sync layer applied is already shared.\n\t\tif (origin === this || !this.#connected) return;\n\n\t\tlet id = `${Date.now().toString(36)}-${this.#counter++}`;\n\t\tthis.#outbox.set(id, update);\n\t\tthis.#outboxBytes += update.byteLength;\n\t\tthis.#unsent.add(id);\n\t\tif (this.saturated) this.#coalesce();\n\n\t\tif (!this.#pacing) this.#flush();\n\t};\n\n\t/** Send what this interval produced, and hold anything newer until it ends. */\n\t#flush(): void {\n\t\tif (!this.#epoch || this.#unsent.size === 0) return;\n\t\tlet ids = this.#merge([...this.#unsent]);\n\t\tthis.#unsent.clear();\n\t\tfor (let id of ids) this.#send(id);\n\t\tthis.#pacing = setTimeout(() => {\n\t\t\tthis.#pacing = undefined;\n\t\t\tthis.#flush();\n\t\t}, SEND_MS);\n\t}\n\n\t/**\n\t * Send again whatever has gone a whole interval without an acknowledgement.\n\t *\n\t * Yjs updates are idempotent, so resending one that was merely slow costs\n\t * a duplicate; not resending one that was dropped costs everything after it.\n\t */\n\t#resend(): void {\n\t\tthis.#resending = undefined;\n\t\tif (!this.#connected || !this.#synced || !this.#epoch) {\n\t\t\t// The next open replays the whole outbox.\n\t\t\tthis.#overdue.clear();\n\t\t\treturn;\n\t\t}\n\t\tlet overdue = [...this.#outbox.keys()].filter(id =>\n\t\t\tthis.#overdue.has(id) && !this.#unsent.has(id) && (this.#sends.get(id) ?? 0) < MAX_SENDS\n\t\t);\n\t\tif (overdue.length > 0) {\n\t\t\tthis.#resendDelay = Math.min(this.#resendDelay * 2, MAX_RESEND_MS);\n\t\t\tfor (let id of this.#merge(overdue)) this.#send(id);\n\t\t}\n\t\tthis.#overdue = new Set(this.#outbox.keys());\n\t\tlet waiting = [...this.#outbox.keys()].some(id => (this.#sends.get(id) ?? 0) < MAX_SENDS);\n\t\tif (waiting) this.#armResend();\n\t}\n\n\t#armResend(): void {\n\t\tthis.#resending ??= setTimeout(() => this.#resend(), this.#resendDelay);\n\t}\n\n\t/** Stop resending what is outstanding now. The next open still replays it. */\n\t#park(): void {\n\t\tfor (let id of this.#outbox.keys()) {\n\t\t\tif (!this.#unsent.has(id)) this.#sends.set(id, MAX_SENDS);\n\t\t}\n\t}\n\n\t#stopTimers(): void {\n\t\tclearTimeout(this.#pacing);\n\t\tclearTimeout(this.#resending);\n\t\tthis.#pacing = undefined;\n\t\tthis.#resending = undefined;\n\t\tthis.#unsent.clear();\n\t\tthis.#overdue.clear();\n\t\tthis.#sends.clear();\n\t\tthis.#resendDelay = RESEND_MS;\n\t}\n\n\t/**\n\t * Send one update.\n\t *\n\t * Fire-and-forget rather than a correlated request: acknowledgements arrive\n\t * as `plan:ack` and are matched by `id`, so a keystroke does not cost a\n\t * pending promise, and an update whose ack never arrives stays in the\n\t * outbox until `#resend` or the next open sends it again.\n\t */\n\t#send(id: string): void {\n\t\tlet update = this.#outbox.get(id);\n\t\tif (!this.#epoch || !update) return;\n\t\tthis.#wire.send(\"plan:update\", { epoch: this.#epoch, id, update: encode(update) });\n\t\tthis.#sends.set(id, (this.#sends.get(id) ?? 0) + 1);\n\t\tthis.#armResend();\n\t}\n\n\t#settle(id: string): void {\n\t\tlet update = this.#outbox.get(id);\n\t\tif (!update) return;\n\t\tthis.#outbox.delete(id);\n\t\tthis.#outboxBytes -= update.byteLength;\n\t\tthis.#overdue.delete(id);\n\t\tthis.#sends.delete(id);\n\t\t// The server is accepting again, so the next resend need not wait long.\n\t\tthis.#resendDelay = RESEND_MS;\n\t}\n\n\t#remote(event: Plan.Update): void {\n\t\tif (event.epoch !== this.#epoch) return;\n\t\tthis.#options.onRemoteUpdate?.(event.agent === true);\n\t\tY.applyUpdate(this.#doc, decode(event.update), this);\n\t}\n\n\t// -- presence ------------------------------------------------------------\n\n\t#announce = (\n\t\t{ added, updated, removed }: { added: number[]; updated: number[]; removed: number[] },\n\t\torigin: unknown,\n\t): void => {\n\t\tif (origin === this || !this.#connected || !this.#epoch) return;\n\n\t\tlet changed = [...added, ...updated, ...removed];\n\t\tif (changed.length === 0) return;\n\n\t\tthis.#wire.send(\"plan:awareness\", {\n\t\t\tepoch: this.#epoch,\n\t\t\tupdate: encode(encodeAwarenessUpdate(this.awareness, changed)),\n\t\t});\n\t};\n\n\t#presence(event: Plan.Awareness): void {\n\t\tif (event.epoch !== this.#epoch) return;\n\t\tapplyAwarenessUpdate(this.awareness, decode(event.update), this);\n\t}\n\n\t// -- epoch rotation ------------------------------------------------------\n\n\t/**\n\t * The server replaced the document.\n\t *\n\t * Local state describes a history that no longer exists, so it is discarded\n\t * rather than merged. Undo and cursors are lost by design — this is the\n\t * boundary where continuity ends.\n\t */\n\t#reset(event: Plan.Reset): void {\n\t\t// The same epoch is the server refusing an oversized update while\n\t\t// keeping the document. Sending it again would be refused again.\n\t\tif (event.epoch === this.#epoch) return this.#park();\n\t\tthis.#discard(event.reason);\n\t}\n\n\t#discard(reason: Plan.Reset[\"reason\"]): void {\n\t\tlet lost = this.#outbox.size > 0;\n\t\tthis.#outbox.clear();\n\t\tthis.#stopTimers();\n\t\tthis.#generation++;\n\t\tthis.#outboxBytes = 0;\n\t\tthis.#epoch = undefined;\n\t\tthis.#synced = false;\n\n\t\tthis.#emit(\"sync\", false);\n\t\tthis.#options.onReset?.(reason, lost);\n\t}\n\n\tget synced(): boolean {\n\t\treturn this.#synced;\n\t}\n}\n","editable",false,"branch","documentNavigation","repo","githubnext/chopin","repoId","7d1a8ac3-35b0-4dea-85d4-06a980f3bada","ownerId","org:89615882","site","nexthub","private","admin","settings","maintainer","triage","starred","stars",0,"watchers","watching","pinned","notify","views",[183,184,185,186,187,188,189,190,191,192,193,194,195],"navigation",{"_55":56,"_139":140,"_141":142,"_143":144,"_145":146,"_147":148,"_149":150},"sources",[],"viewer","meta",{"_131":132,"_133":134,"_135":136,"_43":32,"_137":14,"_138":32,"_49":50,"_51":50},"branches",[74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,14,127,128,129,130],"tags",[70,71,72,73],"cloneUrl","https://git.nexthub.sh/githubnext/chopin.git","color-controls-slice-1","color-controls-slice-2","color-controls-slice-3","color-controls-slice-4","Krzysztof-Cieslak-patch-1","Krzysztof-Cieslak-patch-2","Maggie/app-preview-toolkit","Maggie/ci-playwright-install-timeout","Maggie/collaborative-visual-decision","Maggie/design-audit","Maggie/generic-visual-decision-runtime","Maggie/impeccable-chopin-metadata","Maggie/jev-chat-product","Maggie/jev-composed-assessment","Maggie/native-document-layouts","Maggie/openui-composition-product","Maggie/openui-composition-trial","Maggie/planner-visual-authoring","Maggie/planner-visual-requests","Maggie/visual-selection-eval","artifacts/pr-419-live-preview-20261009","automation/pr-maintenance-state","automation/use-effect/callout-disabled-picker-8cf9e49ba5c09471","automation/use-effect/collaboration-options-ref-4e3a5a08a879a5ae","automation/use-effect/room-workspace-effective-access-a57d40866c71bed0","chore/bun-1.4.2","color-controls","color-controls-plan","comments","design-pr-assets","design/archived-decisions-badge","design/channel-route-remount","design/chat-decision-entry","design/conversation-analysis-markers","design/decision-evidence","design/settled-line-icon","dev/integration","diagram-step-controls","feat/liveapp-frontend-pilot","feat/local-experiments","feat/local-launcher-tracer","fix/autolink-mdx-crash","github-pills/2-pills","github-pills/3-hover-card","maggie/app-preview-toolkit","maggie/ci-playwright-install-timeout","maggie/collaborative-visual-decision","maggie/design-audit","maggie/generic-visual-decision-runtime","maggie/impeccable-chopin-metadata","maggie/jev-composed-assessment","maggie/native-document-layouts","maggie/openui-composition-product","maggie/openui-composition-trial","maggie/planner-visual-authoring","maggie/planner-visual-requests","maggie/visual-selection-eval","plain-text-fence-chrome","tokens/09-copy","wireframes/2-renderer","wireframes/3-planner","description","Let's compose rich plans together","owner","githubnext","section","","head","empty","pins",[165,166,167],"documents",{"_160":161,"_162":163},"code",{"_156":157,"_158":159},"automations",{"_153":154,"_155":-5},"delivery",{"_151":50,"_152":-5},"tag","04zvKQ8QOrDUF8TO1Ovz0Zy8_TT","releases","applications","workflows",3,"deployments","commits",1000,"changes",13,"counts",{"_164":163},"total",11,"issue",{"_168":158,"_170":181,"_15":158,"_172":182,"_53":174,"_175":32,"_176":174,"_177":159},{"_168":178,"_170":179,"_15":178,"_172":180,"_53":174,"_175":32,"_176":174,"_177":50},{"_168":169,"_170":171,"_15":169,"_172":173,"_53":174,"_175":32,"_176":174,"_177":163},"id","issues","name","Issues","filters",{},true,"saved","pinnable","count","tasks","Tasks",{},"Changes",{},{"_168":158,"_170":181,"_15":158,"_172":226,"_53":174,"_175":32,"_176":174},{"_168":178,"_170":179,"_15":178,"_172":225,"_53":174,"_175":32,"_176":174},{"_168":169,"_170":171,"_15":169,"_172":224,"_53":174,"_175":32,"_176":174},{"_168":221,"_170":222,"_15":221,"_172":223,"_53":32,"_175":32,"_176":174},{"_168":218,"_170":219,"_15":218,"_172":220,"_53":32,"_175":32,"_176":174},{"_168":153,"_170":216,"_15":145,"_172":217,"_53":32,"_175":32,"_176":174},{"_168":155,"_170":213,"_15":214,"_172":215,"_53":32,"_175":32,"_176":174},{"_168":151,"_170":211,"_15":151,"_172":212,"_53":32,"_175":32,"_176":174},{"_168":207,"_170":208,"_15":209,"_172":210,"_53":32,"_175":32,"_176":174},{"_168":141,"_170":205,"_15":141,"_172":206,"_53":32,"_175":32,"_176":32},{"_168":202,"_170":203,"_15":202,"_172":204,"_53":32,"_175":32,"_176":32},{"_168":199,"_170":200,"_15":199,"_172":201,"_53":32,"_175":32,"_176":32},{"_168":196,"_170":197,"_15":196,"_172":198,"_53":32,"_175":32,"_176":32},"decisions","Decisions",{},"changelog","Changelog",{},"roadmap","Roadmap",{},"Documents",{},"activity","Activity","insights",{},"Releases",{},"Deployments","automations/deployments",{},"Workflows",{},"discussions","Discussions",{},"goals","Goals",{},{},{},{},"groups","user","agents",[],"now",1794435513877,"sidebar","expanded"]