[{"_1":2,"_183":-5,"_184":-5},"loaderData",{"_3":4,"_93":94},"root",{"_5":6,"_36":37,"_66":67},"ctx",{"_7":8,"_23":-5,"_24":25,"_26":27,"_28":20,"_29":20,"_30":20,"_31":-5,"_32":33,"_34":20,"_35":20},"auth",{"_9":-5,"_10":-5,"_11":-5,"_12":-5,"_13":-5,"_14":-5,"_15":-5,"_16":-5,"_17":-5,"_18":-5,"_19":20,"_21":22},"sessionClaims","sessionId","sessionStatus","userId","actor","orgId","orgRole","orgSlug","orgPermissions","factorVerificationAge","isAuthenticated",false,"tokenType","session_token","user","preferencesKeybindings","default","preferencesTheme","light","preferencesFixers","preferencesCopilot","preferencesSelectionAi","preferencesChatPanelState","notificationCount",0,"flagDenols","isTeamOrgMember","ENV",{"_38":39,"_40":41,"_42":43,"_44":45,"_46":47,"_48":49,"_50":51,"_52":53,"_54":55,"_56":57,"_58":59,"_60":61,"_62":63,"_64":65},"REACT_APP_SENTRY_DSN","https://586020d86f05489db63a554690acf1e9@o1398359.ingest.sentry.io/6724499","VAL_RUNTIME_NAME","prod","RENDER_GIT_COMMIT","1ed3b00b191d67ef967325d666dac7a18ce9a124","RENDER_GIT_BRANCH","main","CLERK_PUBLISHABLE_KEY","pk_live_Y2xlcmsudmFsLnRvd24k","POSTHOG_API_TOKEN","phc_nmoyuAkStEZuUp69rYlg1DZgrIt19Gx0Y4Hwf8tGgJP","POSTHOG_API_HOST","https://wart.val.town","WEB_API_TEMPLATE","https://{val}.web.val.run","APP_URL","https://www.val.town","MODULE_URL","https://esm.town","VANITY_WEB_API_TEMPLATE","https://{label}.val.run/","DENOLS_URL","https://lsp.val.town","NODE_ENV","production","API_URL","https://api.val.town","clerkState",{"_68":69},"__internal_clerk_state",{"_70":71,"_72":47,"_73":74,"_75":74,"_76":20,"_77":74,"_78":74,"_79":74,"_80":74,"_81":82,"_91":20,"_92":20},"__clerk_ssr_state",{"_21":22,"_9":-5,"_10":-5,"_11":-5,"_12":-5,"_13":-5,"_14":-5,"_15":-5,"_16":-5,"_17":-5,"_18":-5,"_19":20},"__publishableKey","__proxyUrl","","__domain","__isSatellite","__signInUrl","__signUpUrl","__afterSignInUrl","__afterSignUpUrl","__clerk_debug",{"_83":20,"_19":20,"_84":74,"_85":86,"_87":74,"_88":47,"_89":20,"_90":74},"isSignedIn","proxyUrl","reason","session-token-and-uat-missing","message","publishableKey","isSatellite","domain","__telemetryDisabled","__telemetryDebug","routes/embed.x.$handle.$name.$",{"_95":96,"_97":98,"_99":100,"_101":102,"_158":159,"_179":180,"_181":182},"handle","c15r","name","sync","path","reference/kernel.ts","project",{"_103":104,"_97":98,"_105":106,"_107":-5,"_108":20,"_109":110,"_111":112,"_113":-5,"_12":114,"_115":-5,"_116":20,"_117":-5,"_118":-5,"_119":120,"_14":121,"_122":123,"_124":125,"_126":-5,"_127":128,"_129":128,"_130":131,"_132":131,"_133":131,"_134":128,"_135":128,"_23":136,"_139":140,"_144":145,"_157":20},"id","93e19588-0ebb-11f1-a6cd-42dde27851f2","createdAt",["D",1771633422787],"deletedAt","legacyEnvVars","privacy","public","description","Agent collaboration layer https://sync.parc.land","imageUrl","21f2e37e-8066-4730-9dc7-d27cf8d3c9f3","pinnedFileId","pinPreview","pinMigrated","screenshotVersion","likeCount",1,"0630d977-f678-453e-926c-52043293f59f","tursoName","93e195880ebb11f1a6cd42dde27851f2","tursoHostname","93e195880ebb11f1a6cd42dde27851f2-val-town.aws-us-east-2.turso.io","pinned","userPerm","r","valPerm","blobPerm","rw","emailPerm","sqlitePerm","projectPerm","telemetryPerm",{"_95":96,"_137":138},"profileImageUrl","https://img.clerk.com/eyJ0eXBlIjoicHJveHkiLCJzcmMiOiJodHRwczovL2ltYWdlcy5jbGVyay5kZXYvb2F1dGhfZ2l0aHViL2ltZ18yb2RJNlc1czZ1NlpZRmoxdGJ2eFVNNVhmeTYifQ","org",{"_95":96,"_141":138,"_12":114,"_142":143},"avatar","tier","pro","branch",{"_146":147,"_97":45,"_103":148,"_149":104,"_150":-5,"_151":-5,"_152":-5,"_153":-5,"_154":-5,"_155":98,"_156":96},"version",639,"93e21602-0ebb-11f1-a6cd-42dde27851f2","projectId","forkedBranchId","forkedBranchVersion","forkedProjectPrivacy","forkedProjectId","forkedProjectOrgId","projectName","userHandle","isOwned","file",{"_103":160,"_97":161,"_162":163,"_164":165,"_166":148,"_167":168,"_169":170,"_105":171,"_146":33,"_172":158,"_173":174,"_175":20,"_176":-5,"_99":177},"436a269c-1b9f-11f1-ad94-42dde27851f2","kernel.ts","fileId","436a2782-1b9f-11f1-ad94-42dde27851f2","parentId","b2302ce2-1097-11f1-8f1d-42dde27851f2","branchId","branchVersion",430,"latest",true,["D",1773050626986],"fileType","content","/**\n * sync/kernel.ts — the substrate algebra\n *\n * The entire model in pure functions. No I/O, no framework,\n * no persistence. Bring your own storage and transport.\n *\n * Five types. Seven operations. One loop.\n *\n * read → evaluate → act → read → ...\n *\n * Everything else is a shell built around this kernel.\n */\n\n// ── Types ──────────────────────────────────────────────\n\n/** A located key: scope + name. The scope is the authority boundary. */\nexport type Loc = { scope: string; key: string };\n\n/** The substrate: a finite partial function from located keys to values. */\nexport type State = Map>;\n\n/** A state entry: value + version for compare-and-swap. */\nexport type Entry = {\n value: unknown;\n version: number; // monotonic revision counter\n hash: string; // content hash — proof-of-read token\n};\n\n/** An action: a named state transition with preconditions and write templates. */\nexport type Action = {\n id: string;\n scope: string; // authority scope — constrains where writes can land\n intent?: string; // natural-language purpose (survives implementation failure)\n pred?: Pred; // precondition — must hold for invocation to proceed\n writes: WriteTemplate[];\n params?: ParamSchema;\n};\n\n/** A view: a named derived computation over state. */\nexport type View = {\n id: string;\n scope: string; // registrar scope — determines what state is visible\n compute: (state: State, views: Record) => unknown;\n};\n\n/** A room: state + vocabulary. The world model. */\nexport type Room = {\n state: State;\n actions: Map;\n views: Map;\n agents: Set;\n seq: number; // global sequence number for ordering\n};\n\n/** The context envelope: what an agent perceives on a read. */\nexport type Context = {\n state: Record>;\n views: Record;\n actions: Record;\n agents: string[];\n self: string | null;\n seq: number;\n};\n\n/** Predicate over state. */\nexport type Pred = (state: State, params: Record) => boolean;\n\n/** Write template: declarative state mutation. */\nexport type WriteTemplate = {\n scope: string; // target scope (may contain ${self})\n key: string; // target key (may contain ${params.x})\n value: unknown | ((params: Record, state: State) => unknown);\n append?: boolean; // append to sequence rather than overwrite\n merge?: boolean; // shallow-merge into existing object\n ifVersion?: string; // compare-and-swap guard\n};\n\n/** Parameter schema for an action. */\nexport type ParamSchema = Record;\n\n/** Result of an invocation. */\nexport type InvokeResult =\n | { ok: true; room: Room; writes: Array<{ scope: string; key: string; value: unknown }> }\n | { ok: false; error: string; detail?: unknown };\n\n// ── Constructors ───────────────────────────────────────\n\n/** Empty room. Four built-in actions. Nothing else. */\nexport function createRoom(): Room {\n return {\n state: new Map(),\n actions: new Map(),\n views: new Map(),\n agents: new Set(),\n seq: 0,\n };\n}\n\n/** Hash a value for content-addressable versioning. */\nfunction hash(value: unknown): string {\n const str = typeof value === \"string\" ? value : JSON.stringify(value);\n // djb2 — good enough for the kernel. Real impl uses SHA-256.\n let h = 5381;\n for (let i = 0; i < str.length; i++) h = ((h << 5) + h + str.charCodeAt(i)) >>> 0;\n return h.toString(16).padStart(8, \"0\");\n}\n\n// ── State operations ───────────────────────────────────\n\n/** Read a value from the substrate. Returns undefined for absent keys. */\nexport function read(state: State, scope: string, key: string): unknown | undefined {\n return state.get(scope)?.get(key)?.value;\n}\n\n/** Read an entry (value + version + hash). */\nexport function readEntry(state: State, scope: string, key: string): Entry | undefined {\n return state.get(scope)?.get(key);\n}\n\n/** Write a value to the substrate. Returns a new State (immutable). */\nexport function write(state: State, scope: string, key: string, value: unknown): State {\n const next = cloneState(state);\n if (!next.has(scope)) next.set(scope, new Map());\n const scopeMap = next.get(scope)!;\n const existing = scopeMap.get(key);\n scopeMap.set(key, {\n value,\n version: existing ? existing.version + 1 : 1,\n hash: hash(value),\n });\n return next;\n}\n\n/** Write with compare-and-swap. Fails if current hash doesn't match. */\nexport function writeIfVersion(\n state: State, scope: string, key: string, value: unknown, expectedHash: string\n): State | { conflict: true; current: Entry | undefined } {\n const current = readEntry(state, scope, key);\n const currentHash = current?.hash ?? \"\";\n if (currentHash !== expectedHash) return { conflict: true, current };\n return write(state, scope, key, value);\n}\n\n/** Append to a log scope (auto-incrementing key). */\nexport function append(state: State, scope: string, value: unknown, seq: number): State {\n return write(state, scope, String(seq), value);\n}\n\n/** Merge an object into an existing object value. */\nexport function merge(state: State, scope: string, key: string, patch: Record): State {\n const existing = read(state, scope, key);\n const base = (existing && typeof existing === \"object\" && !Array.isArray(existing))\n ? existing as Record\n : {};\n return write(state, scope, key, { ...base, ...patch });\n}\n\n/** List all keys in a scope. */\nexport function keys(state: State, scope: string): string[] {\n const scopeMap = state.get(scope);\n return scopeMap ? [...scopeMap.keys()] : [];\n}\n\n/** List all scopes. */\nexport function scopes(state: State): string[] {\n return [...state.keys()];\n}\n\n// ── Room operations ────────────────────────────────────\n\n/** Register an action. Idempotent — same ID overwrites. */\nexport function registerAction(room: Room, action: Action): Room {\n const actions = new Map(room.actions);\n actions.set(action.id, action);\n return { ...room, actions };\n}\n\n/** Delete an action. */\nexport function deleteAction(room: Room, id: string): Room {\n const actions = new Map(room.actions);\n actions.delete(id);\n return { ...room, actions };\n}\n\n/** Register a view. Idempotent — same ID overwrites. */\nexport function registerView(room: Room, view: View): Room {\n const views = new Map(room.views);\n views.set(view.id, view);\n return { ...room, views };\n}\n\n/** Delete a view. */\nexport function deleteView(room: Room, id: string): Room {\n const views = new Map(room.views);\n views.delete(id);\n return { ...room, views };\n}\n\n/** Join a room as an agent. */\nexport function join(room: Room, agentId: string): Room {\n const agents = new Set(room.agents);\n agents.add(agentId);\n return { ...room, agents };\n}\n\n/** Leave a room. State persists. */\nexport function leave(room: Room, agentId: string): Room {\n const agents = new Set(room.agents);\n agents.delete(agentId);\n return { ...room, agents };\n}\n\n// ── View resolution ────────────────────────────────────\n\n/** Resolve all views, producing a map of view ID → computed value.\n * Views that error get { _error: message }. */\nexport function resolveViews(room: Room): Record {\n const results: Record = {};\n for (const [id, view] of room.views) {\n try {\n results[id] = view.compute(room.state, results);\n } catch (e: unknown) {\n results[id] = { _error: e instanceof Error ? e.message : String(e) };\n }\n }\n return results;\n}\n\n// ── Context assembly ───────────────────────────────────\n\n/** Build the context envelope — what an agent sees on a read.\n * Respects scope privacy: only _shared, self scope, and _system scopes visible. */\nexport function context(room: Room, self: string | null = null): Context {\n // Resolve views\n const views = resolveViews(room);\n\n // Build visible state\n const visibleState: Record> = {};\n for (const [scope, entries] of room.state) {\n const isShared = scope === \"_shared\";\n const isSystem = scope.startsWith(\"_\");\n const isSelf = self !== null && scope === self;\n if (!isShared && !isSystem && !isSelf) continue;\n const obj: Record = {};\n for (const [key, entry] of entries) obj[key] = entry.value;\n const contextScope = isSelf && !isShared ? \"self\" : scope;\n visibleState[contextScope] = obj;\n }\n\n // Build action availability\n const actions: Record = {};\n for (const [id, action] of room.actions) {\n let available = true;\n if (action.pred) {\n try { available = action.pred(room.state, {}); }\n catch { available = false; }\n }\n actions[id] = {\n available,\n ...(action.intent ? { intent: action.intent } : {}),\n };\n }\n\n return {\n state: visibleState,\n views,\n actions,\n agents: [...room.agents],\n self,\n seq: room.seq,\n };\n}\n\n// ── Invocation ─────────────────────────────────────────\n\n/** Invoke an action. Pure function: room in, room out.\n *\n * 1. Find the action.\n * 2. Check the precondition.\n * 3. Resolve write templates against params.\n * 4. Check scope authority.\n * 5. Apply writes.\n * 6. Return new room + executed writes. */\nexport function invoke(\n room: Room,\n actionId: string,\n params: Record = {},\n agent: string | null = null,\n): InvokeResult {\n\n const action = room.actions.get(actionId);\n if (!action) return { ok: false, error: \"action_not_found\", detail: actionId };\n\n // Check precondition\n if (action.pred) {\n try {\n if (!action.pred(room.state, params)) {\n return { ok: false, error: \"precondition_failed\", detail: action.id };\n }\n } catch (e: unknown) {\n return { ok: false, error: \"predicate_error\", detail: e instanceof Error ? e.message : String(e) };\n }\n }\n\n // Execute writes\n let state = room.state;\n let seq = room.seq;\n const executedWrites: Array<{ scope: string; key: string; value: unknown }> = [];\n\n for (const w of action.writes) {\n // Resolve scope template\n const scope = resolveTemplate(w.scope, params, agent);\n\n // Authority check: action scope constrains write scope\n if (scope !== \"_shared\" && !scope.startsWith(\"_\")) {\n if (scope !== action.scope && scope !== agent) {\n return { ok: false, error: \"scope_denied\", detail: { action: actionId, scope } };\n }\n }\n\n // Resolve key template\n const key = w.append ? String(++seq) : resolveTemplate(w.key, params, agent);\n\n // Resolve value\n const value = typeof w.value === \"function\" ? w.value(params, state) : resolveTemplate(w.value, params, agent);\n\n // Compare-and-swap guard\n if (w.ifVersion !== undefined) {\n const result = writeIfVersion(state, scope, key, value, w.ifVersion);\n if (\"conflict\" in result) {\n return { ok: false, error: \"version_conflict\", detail: { scope, key, expected: w.ifVersion } };\n }\n state = result;\n } else if (w.merge) {\n state = merge(state, scope, key, value as Record);\n } else {\n state = write(state, scope, key, value);\n }\n\n executedWrites.push({ scope, key, value });\n }\n\n // Append invocation to audit log\n seq++;\n state = append(state, \"_audit\", { agent, action: actionId, params, writes: executedWrites, at: seq }, seq);\n\n return {\n ok: true,\n room: { ...room, state, seq },\n writes: executedWrites,\n };\n}\n\n// ── Template resolution ────────────────────────────────\n\n/** Resolve ${params.x}, ${self}, ${now} in a value. Recursive for objects. */\nfunction resolveTemplate(value: unknown, params: Record, agent: string | null): any {\n if (typeof value === \"string\") {\n return value.replace(/\\$\\{(params\\.(\\w+)|self|now)\\}/g, (_match, full, paramName) => {\n if (paramName !== undefined) return String(params[paramName] ?? \"\");\n if (full === \"self\") return agent ?? \"\";\n if (full === \"now\") return new Date().toISOString();\n return _match;\n });\n }\n if (Array.isArray(value)) return value.map(v => resolveTemplate(v, params, agent));\n if (value !== null && typeof value === \"object\") {\n const out: Record = {};\n for (const [k, v] of Object.entries(value)) out[k] = resolveTemplate(v, params, agent);\n return out;\n }\n return value;\n}\n\n// ── Utilities ──────────────────────────────────────────\n\n/** Deep clone a State map. */\nfunction cloneState(state: State): State {\n const next = new Map>();\n for (const [scope, entries] of state) {\n next.set(scope, new Map(entries));\n }\n return next;\n}\n\n// ── Wait (the only impure operation) ───────────────────\n\n/** Wait for a predicate to become true. The substrate's only blocking operation.\n * In a real system this polls or subscribes. Here it's a contract. */\nexport type WaitHandle = {\n predicate: Pred;\n resolve: (ctx: Context) => void;\n};\n\n/** Create a wait handle. The shell is responsible for checking it on each state change. */\nexport function wait(pred: Pred): { promise: Promise; handle: WaitHandle } {\n let handle: WaitHandle;\n const promise = new Promise((resolve) => {\n handle = { predicate: pred, resolve };\n });\n return { promise, handle: handle! };\n}\n\n/** Check all pending waits against current state. Fire those whose predicates hold. */\nexport function checkWaits(room: Room, waits: WaitHandle[], self: string | null = null): WaitHandle[] {\n const remaining: WaitHandle[] = [];\n for (const w of waits) {\n try {\n if (w.predicate(room.state, {})) {\n w.resolve(context(room, self));\n } else {\n remaining.push(w);\n }\n } catch {\n remaining.push(w);\n }\n }\n return remaining;\n}\n\n// ── Contested targets (synthetic view) ─────────────────\n\n/** Compute which state keys are written by 2+ actions. */\nexport function contested(room: Room): Record {\n const targets: Record = {};\n for (const [id, action] of room.actions) {\n for (const w of action.writes) {\n if (w.append) continue; // append writes don't contest\n const target = `${w.scope}:${w.key}`;\n if (!targets[target]) targets[target] = [];\n targets[target].push(id);\n }\n }\n const result: Record = {};\n for (const [target, ids] of Object.entries(targets)) {\n if (ids.length >= 2) result[target] = ids;\n }\n return result;\n}\n\n// ── That's it. ─────────────────────────────────────────\n//\n// Five types: State, Action, View, Room, Context\n// Seven ops: read, write, register, invoke, context, wait, resolve\n// One loop: read → evaluate → act → read\n//\n// Everything else — HTTP, SQL, OAuth, MCP, dashboards,\n// timers, surfaces, help, audit — is a shell around this kernel.\n//\n// The room is the world model.\n// Actions are the transition function.\n// Views are the observation function.\n// Context is the affordance map.\n// The audit log is the trajectory.\n//\n// What's missing? The reward signal.\n// That's adaptive salience.\n//\n","deleted","label",[178,161],"reference","permalink","https://www.val.town/x/c15r/sync/code/reference/kernel.ts","extension","ts","actionData","errors"]