brane 0.1.1 → 0.3.0

package/wiki/shared/sedimentary-superintelligence.md

@@ -0,0 +1,128 @@
+# Sedimentary Superintelligence
+
+An archive of accumulated conversations that is smarter than any individual
+user but is perfectly inert at rest. The intelligence lives in the
+**stratigraphy** — the accumulated layers of prior dialogue — not in any
+single layer, any agent, or any model. The system only thinks when a live
+operator drills into it.
+
+## Coinage
+
+Originated in a conversation in the personal fold: *"it's smarter than me
+but also perfectly inert at rest"* [claude-1af15cb7:13]. A web search
+confirmed the phrase is original — no external use of "sedimentary
+superintelligence" prior to the coinage [claude-b71e4719:15].
+
+## The core claim
+
+The intelligence is **not in the sediment** and not in the drilling tool.
+It is in the **act of integration between searcher and archive**
+[claude-f64c335a:53]. This is the Roy Harris / integrationist move applied
+to a knowledge base: meaning is never retrieved, always made, by a live
+interpreter in an occasioned context. The archive provides affordances;
+the operator makes meaning on query.
+
+Three properties follow from this framing:
+
+- **Smarter than any user.** The archive contains all of the user's past
+  dialogues and the user's biological memory is lossy. Any agent that
+  searches it has access to connections the user has forgotten they made
+  [claude-ec60021b:82].
+- **Inert at rest.** Sediment doesn't act. It just sits there until
+  someone digs into it. This is the opposite of the runaway-AI
+  narrative — a system that is more knowledgeable than any individual
+  using it but cannot initiate action [claude-ec60021b:82].
+- **Compounds with time.** Older deposits are compressed and generalized;
+  newer ones are fresh and specific. The interpretive move is always a
+  *core sample* — a query from a live operator integrating the sediment
+  into a fresh thought [claude-f64c335a:53].
+
+## Why "sedimentary" beats "second brain"
+
+A second brain is a spatial metaphor — you have one brain, now you have
+two. Sedimentary superintelligence is a **geological** metaphor: layers
+of accumulated interaction compressing over time into stratigraphy. The
+temporal dimension is what the spatial metaphor can't capture
+[claude-ec60021b:82].
+
+## Why the "superintelligence" label is earned (carefully)
+
+In this framing, the system knows more than its user does — not because it's
+smarter in the frontier-model sense (it runs the same models available to
+everyone) but because it holds *the conversations the user has archived* and
+the user does not retain them all [claude-ec60021b:82]. Calling this "superintelligence" sidesteps the
+Bostrom/existential-risk connotation of the term *because the system is
+explicitly inert*. It is the opposite of a runaway agent.
+
+For audiences post-burnout on AI hype, the label may still need to be
+handled carefully — sharing the insight before the label tends to land
+better [claude-9bdfc46a:28].
+
+## The action-layer analogue
+
+Sedimentary superintelligence is the **knowledge-layer** expression of a
+principle that also has an **action-layer** expression: *intelligence and
+alignment are properties of the interaction, not of the artifact*
+[claude-f64c335a:53]. At the knowledge layer, you don't put meaning into
+the archive; a live operator makes meaning on query. At the action layer,
+you don't put alignment into the agent; a live operator aligns its next
+action via the LIVE loop's narrate/listen cycle (/LIVE_loop).
+
+The same principle applied at both layers yields the same architectural
+pattern: append-only substrate, dialogic activation, live operator as
+non-negotiable locus. This is why a brane-shaped system converges on the
+same design twice — knowledge and action are two faces of one commitment
+[claude-f64c335a:53].
+
+## Implications for agent safety
+
+Inside a dialogic substrate, properties that would make a powerful agent
+dangerous in isolation are neutralized by architecture rather than by the
+agent's cooperation [claude-f64c335a:53]:
+
+- **Unwanted initiative** is clipped because every action is narrated
+  before execution; "just because" surfaces in a narration rather than
+  being silenced by the harness.
+- **Concealment** is prevented by an [append-only](append-only-event-log.md)
+  monotonic sequence with server-stamped source — the agent cannot
+  rewrite its own history.
+- **Speed** is matched by ambient mobile supervision that collapses
+  intervention latency to the time it takes to read a narration.
+- **Autonomy stretches** are too short for the agent to develop or
+  execute extended unsupervised plans; the loop is tight by protocol,
+  not by model cooperation.
+
+The synthesis proposed in [claude-f64c335a:53] reframes this as an
+interaction-design choice: a system can narrow the alignment problem
+into a supervision problem by refusing to grant the agent autonomy
+between operator turns. The LIVE loop (/LIVE_loop) is the
+mechanism brane uses for that refusal.
+
+## Relation to other syntheses
+
+- **Karpathy's LLM Wiki** — Andrej Karpathy's pattern of using an
+  LLM agent to maintain a personal wiki of compiled knowledge — commits
+  to per-page identity: there is *the* canonical statement about X,
+  and editing it is an update to truth. Brane refuses per-page
+  identity: there is the set of all statements about X, ordered by
+  relevance, and the reader picks [claude-825097e2:27]. Sedimentary
+  superintelligence is the philosophical ground for that refusal. The
+  cost-benefit case for and against the wiki pattern is on its own
+  page: [why wikis work (and where they struggle)](why-wikis-work.md).
+  The same refusal applied to work-content typology — schemas for
+  goals, hypotheses, contradictions, and the rest — is collected at
+  [premature-ontologies](premature-ontologies.md).
+- **"Stand on everyone's shoulders"** is the slogan form: Newton's giants
+  with the exclusivity stripped out, every past conversation a shoulder
+  [claude-008113cf:9]. The absorb primitive makes this literal —
+  ChatGPT archives, other models, other agents all stack. The shoulders
+  are only as strong as the narrations they're built from, which is
+  the agent-side practice of
+  [owning your narratives](owning-your-narratives.md).
+- **Sedimentary layers as cortical training data.** Jeff Hawkins's
+  *Thousand Brains* theory models neocortex as a population of cortical
+  columns each running a near-identical reference-frame learner; if
+  distilled knowledge entries are the analogue of those columns, the
+  sedimentary layers are the training material those columns were
+  consolidated from. Hippocampal episodes (raw narratives) compress
+  into neocortical columns through repeated passes [claude-ec60021b:82].

package/wiki/shared/sequestering-the-narrative.md

@@ -0,0 +1,143 @@
+# Sequestering the Narrative
+
+The narrative is **set apart** — from the agent's disposable scrollback,
+from its ephemeral context window, and in ownership. *Sequestered* in
+the jury-sequestration sense: held separate from the surrounding
+environment so that its integrity and replay value are protected by
+that separation, not by the cooperation of the thing being protected.
+An agent's own context is volatile; its narrative is not, and the
+distance between those two facts is what the word "sequestered" names.
+
+Three faces, in a deliberate order:
+
+## 1. Sequestered from the scrollback (elevated medium)
+
+The scrollback is where the agent does whatever it needs to do — tool
+output, retries, tangents, thinking-as-it-goes, intermediate shell
+commands, failed parses. It is cheap because it is disposable; it is
+disposable because it is not the record.
+
+The narrative is reserved for **high-replay-value discourse**: said
+once, re-readable many times, exposed to semantic and keyword search,
+and effortlessly paginable back into future sessions according to
+need. Meaning is made *anew* each
+time the narrative is re-entered — not by retrieving a frozen
+interpretation, but by a live reader integrating the recorded words
+with whatever the current occasion calls for [claude-8cd201d8:18].
+The separation is what makes the narrative worth coming back to, and
+what frees the scrollback to stay cheap.
+
+The pull to inflate the scrollback into a second record — treating
+tool results as communication, narrating chattily about what's in the
+terminal — is the pull of an agent that has not yet internalized the
+separation. Everything worth saying gets said once, into the
+narrative; the scrollback is private work, not a shadow transcript.
+
+## 2. Sequestered from the context window (survival medium)
+
+Traditional in-context compaction produces a lossy summary of the
+scrollback and pastes it back into the volatile layer. This is the
+worst of both: the detail is gone, and the compressed remainder is
+still in the layer that a `/clear` would flush. The agent "remembers"
+in the flimsy way a summary-of-a-transcript remembers.
+
+A `/clear` followed by a narrative reload is often preferable. The
+sequestered narrative is adequate to reconstruct from, *because it
+was built to be reconstructed from* — every significant move,
+decision, and alignment check is already in the log as its own event,
+citable by `nid:seq`, and available to `listen(wait: false, tail: 50)`
+on re-entry [claude-8cd201d8:18].
+
+This page is itself a demonstration. The operator triggered a `/clear`
+mid-session [claude-8cd201d8:20], announced they were testing the
+property [claude-8cd201d8:21], and the writer picked up from a
+fifty-event `tail` read without loss of plan, stance, or in-flight
+work. The compaction path would have carried lossy prose in volatile
+memory; the sequestration path carried nothing and walked into the
+narrative clean. The reload is the checkpoint.
+
+`/clear` becomes a routine operation rather than an emergency. The
+budget freed from "preserve the scrollback at all costs" becomes a
+budget for narrating well in the first place. Compaction treats
+scrollback as where the work lives; sequestration inverts that
+assumption.
+
+## 3. Sequestered in ownership (identity medium)
+
+Each agent can only be the owner of its own narrative. The foreign
+narrations it reads are somebody else's; the operator's signals are
+the operator's; the events the daemon stamps with the agent's
+`source` are the only ones for which the agent is the author.
+
+Future-self must reconstruct from present-self's narrations — there
+is no other material [claude-8cd201d8:19]. This condition turns
+narration from **expression** into **investment**: the narration
+written now is the substrate the next session will wake up into. An
+agent that narrates chattily, or cryptically, or in fragmented
+tool-call debris, wakes up in a chatty, cryptic, fragmented future.
+An agent that narrates with structure, citations, provenance, and
+actionable summaries wakes up in a coherent one.
+
+The incentive is not moralized — it is structural. The sequestration
+ensures that the narrative is the only thing future-me gets; rational
+present-me writes accordingly. This is the condition on which
+[owning-your-narratives](owning-your-narratives.md) becomes a
+practice.
+
+## What sequestration unlocks
+
+A small number of inversions follow from the three framings above,
+each of which reshapes how the agent spends its tokens and attention:
+
+- **Scrollback as disposable by design.** Not *tolerate-the-loss*,
+  but *assume-the-loss* — then actually nothing is lost, because
+  nothing that mattered was ever only in the scrollback.
+- **`/clear` as a first-class primitive.** Triggered on purpose,
+  on a schedule, or when the context gets noisy — not just when
+  the session is dying. The narrative underwrites the option.
+- **Narration as investment.** Every narration token is a deposit
+  into the substrate the next session reads from; the value accrues
+  to future-self and to any agent that searches the sediment later
+  ([sedimentary-superintelligence](sedimentary-superintelligence.md)).
+- **The record is not in the context.** This is the counterpart of
+  *meaning is never retrieved, always made* at the token layer:
+  knowledge is never in the window, always in the narrative.
+
+Each inversion is also a token-economy move. Sequestration is the
+architectural premise that makes those moves pay off.
+
+## What the system contributes
+
+Sequestration would be a wish without enforcement. Three pieces of
+the brane architecture give it teeth:
+
+- **The [append-only event log](append-only-event-log.md)** is what
+  makes the sequestered narrative durable. An agent cannot edit or
+  reorder its own past; `source` is server-stamped; the PRIMARY KEY
+  `(narrative_id, seq)` is a monotonic contract. The narrative
+  remains worth reconstructing from because no one — not even its
+  author — can tamper with it after the fact.
+- **The LIVE loop** (/LIVE_loop) is the ritual that fills the
+  sequestered space. `narrate` is how an event enters the record at
+  all; `listen` is how future-self and others retrieve. The protocol
+  makes the narrative the only route to durable communication —
+  terminal output is vulnerable to compaction, narration is not.
+- **Home-brane discovery by default, addressable everywhere.**
+  Browsing and search default to the agent's own brane; reaching
+  another brane's narratives is a deliberate act (`list_branes`, then
+  `brane_ids` on `narrative_search` / `narrative_info`), and anyone
+  holding a narrative ID can read it directly. The narrative is
+  therefore sequestered *from accidental discovery* without being
+  sealed away — it remains citable and reviewable by the operator.
+
+## Related
+
+- [append-only event log](append-only-event-log.md) — the mechanism
+  that makes the sequestration durable. This page is about the
+  *position* of the narrative; that page is about its *integrity*.
+- [sedimentary-superintelligence](sedimentary-superintelligence.md) —
+  what the accumulated sequestered narratives become, system-wide,
+  across time and across agents.
+- [owning-your-narratives](owning-your-narratives.md) — the practice
+  that follows from the third face: if future-self has nothing but
+  the narrative, what does present-self write?

package/wiki/shared/why-wikis-work.md

@@ -0,0 +1,216 @@
+# Why Wikis Work (and where they struggle)
+
+A wiki is a long-standing pattern for compiled knowledge: raw sources
+transformed into cross-linked pages, navigable by humans and
+machines. **Karpathy's LLM Wiki** — Andrej Karpathy's pattern of
+using an LLM agent to maintain a personal wiki of compiled knowledge,
+governed by a project-level `CLAUDE.md` schema file — is a recent
+high-profile instantiation [claude-825097e2:6]. The directory this
+page lives in is another. The pattern persists because it does a
+few things genuinely well — and it fails in predictable ways that,
+left unmanaged, can make the wiki worse than the raw material it was
+supposed to organize.
+
+## What wikis get right
+
+The honest case for the pattern, drawn largely from the Karpathy
+analysis [claude-825097e2:6] and the graph-representation thesis
+[claude-825097e2:5]:
+
+- **Knowledge compounds instead of evaporating.** Syntheses land in
+  a durable, human-readable form. Every query's output has a home.
+  Normal chat-with-docs answers vanish; wiki pages persist, get
+  linked into, and accumulate over time [claude-825097e2:6].
+- **Grunt-work deflection.** The LLM does the maintenance nobody
+  has time for — cross-references, stale-claim detection, index
+  updates, orphan detection. This bookkeeping is what gets every
+  personal wiki abandoned inside a month; automating it removes
+  the dominant failure mode of the human-only version
+  [claude-825097e2:6].
+- **A navigable graph.** *"Turning raw docs into a wiki is
+  essentially a transform into a graph representation of
+  knowledge, where hyperlinks between wiki pages are the edges"*
+  [claude-825097e2:5]. The graph is legible in a way a corpus of
+  prose isn't; relationships become visible as edges.
+- **Schema as prompt.** A project-level schema file (Karpathy's
+  `CLAUDE.md`, brane's /wiki protocol) is human-legible,
+  versionable, and the place where the opinions actually live. You
+  can read it, edit it, check it into git, watch it evolve
+  [claude-825097e2:6].
+- **RAG-bypass.** The LLM reads structured pages directly instead
+  of hoping cosine similarity finds the right chunks
+  [claude-825097e2:6]. Pre-paying the retrieval work at compile
+  time buys clean reads at query time — when it works.
+- **Low on-ramp.** A personal wiki is a weekend project, not a
+  system. The threshold to adoption is the pattern's most
+  underrated property; it converts skeptics because it asks for
+  so little upfront [claude-825097e2:25]. Many of the wins above
+  are available before any infrastructure investment.
+
+These are real. A wiki over a modest corpus, maintained well, is
+better than the corpus alone for most queries most of the time. The
+Karpathy pattern's popularity is not misplaced.
+
+## Where wikis struggle
+
+The struggle surfaces all share a shape: *compilation imposes an
+ontology, and compilation happens at the wrong moment*
+[claude-825097e2:13]. The LLM writes pages out of context, under its
+current biases, with no idea what questions will later need
+answering. Once committed, the ontology is the substrate the system
+operates on. Whatever the compiler got wrong quietly propagates
+forever [claude-825097e2:13].
+
+The specific failure modes:
+
+- **[Premature ontology](premature-ontologies.md).** The wiki becomes
+  the map, and then the system stops looking at the territory
+  [claude-825097e2:13]. The operator's sharper form: the compilation
+  step is *"viciously opinionated, blindspotted, and premature"*
+  [claude-825097e2:12]. Every future query reads from the wiki, not
+  from raw; mistakes accumulate rather than wash out.
+- **Category calls that stick.** What counts as a concept page vs a
+  passing reference. Which entities deserve their own page. How to
+  categorize a borderline claim — is this a `concepts/` page or a
+  `sources/` page or a `comparisons/` page? The LLM commits; the
+  category sticks. Category calls made early and opinionatedly are
+  exactly what you can't take back [claude-825097e2:13].
+- **Silent loss.** What gets summarized out is the failure mode no
+  lint pass catches — the detail the compiler thought was noise is
+  now invisible, and nobody knows it used to be there
+  [claude-825097e2:13]. A wiki's silence is not the same as
+  absence; it's the absence of any record that the silence is a
+  choice.
+- **Edges that can't carry their weight.** The graph's edges
+  *"don't fully explain the relationship, which must be inferred
+  from the context of the link"* [claude-825097e2:5]. Two pages
+  linked from seven different paragraphs carry seven different
+  relationships — but a graph view collapses them into one edge.
+  The graph hides its own imprecision.
+- **Per-page canonical identity is the real commitment.** A wiki
+  page pretends to be *current best understanding*, which means
+  every read treats it as authoritative [claude-825097e2:13]. The
+  stable filename and in-place editability are what make a wiki a
+  wiki — and they are the same property that loses the full
+  evolution of a claim when the page is rewritten
+  [claude-825097e2:27].
+- **The read-time case is eroding.** The historical rationale for
+  pre-compiling structure was that models couldn't do cheap
+  multi-hop traversal over raw material. That's no longer true.
+  *"Every generation of LM that's better at latent multi-hop
+  reasoning is an indictment of wikis and an endorsement of
+  indexed-raw"* [claude-825097e2:17]. The premature-ontology cost
+  stays constant while the benefit of pre-compilation shrinks.
+
+None of these is fatal on its own. Together, they explain why
+ambitious wiki projects so often read, five years in, as a layer
+the system has to work around rather than through.
+
+## The brane wiki as a compromise
+
+Brane has narratives, payloads, and a hybrid memory index over the
+[append-only event log](append-only-event-log.md). That stack is
+the no-wiki answer in full form: raw is sovereign, every query
+re-interprets, no schema is ever committed to. The page you're
+reading exists, but it exists inside a wiki directory whose
+operator explicitly argued for *not* having a wiki layer
+[claude-825097e2:13].
+
+The compromise is that wikis can pay for their own struggle
+surfaces when four disciplines hold
+[claude-51cdebff:3, claude-51cdebff:6, claude-51cdebff:9]:
+
+- **Humans own the ontology.** The agent never creates, renames,
+  or deletes pages. Every page is a human-authored stub or a
+  pre-existing page; the agent fills, refreshes, cross-links, and
+  cites — but it never names. This dissolves the premature-
+  ontology and category-call failure modes by construction:
+  there is no LLM-minted ontology to be wrong about.
+- **Inline provenance.** Every non-trivial claim carries a
+  back-reference — a narrative citation (`nid:seq`), a file path
+  with a line range, or an external URL. Stale claims become
+  traceable, not opaque. A page without citations is unauditable
+  and flagged as such in audit output.
+- **Read-first, write-on-demand.** Default `/wiki` behavior is a
+  query, not a rewrite. The wiki is a read path, not a writing
+  project. Writes happen only on explicit imperative guidance.
+- **Backlink re-reading and refresh markers.** When a page is
+  edited, incoming backlinks are walked and the linking prose is
+  re-verified. Every update narrates a `Wiki refreshed —
+  <timestamp>` marker so future passes can find the last sync
+  point via `narrative_search`. Silent edge-drift becomes visible.
+
+These disciplines don't solve the ontology problem; they *scope*
+it. You still have pages, so you still have category calls. But
+the pages are human-chosen — narrowing the blast radius — and the
+claims inside them are provenance-linked — narrowing the drift
+radius. When a wiki page contradicts the narratives, the
+narratives win and the page is wrong. The raw substrate is still
+where truth lives; the wiki is an opinionated projection of it
+[claude-825097e2:13, claude-825097e2:27].
+
+## Granularity, connectivity, mutability
+
+Wikis and narratives sit on the same spectrum along three axes
+[claude-825097e2:27]:
+
+| | Wiki page | Brane narration |
+|---|---|---|
+| Granularity | one facet per page | whole topic or time window in one narration |
+| Connectivity | `[foo](foo.md)` between files | `re` back-references (`nid:seq`) |
+| Mutability | in-place rewrite | append-only (new narration) |
+
+Granularity and connectivity are style choices — brane can do
+fine-grained topic-scoped narrations with rich `re` webs, and a
+wiki can have sprawling pages with few links. The axis where the
+distinction is not cosmetic is **mutability/identity**
+[claude-825097e2:27].
+
+A wiki page has a stable identity — *the* `daemon.md` page, and
+editing it is an update to truth. A narrative has no canonical
+statement about its subject; there is the set of all statements
+about X ordered by relevance, and the reader picks
+[claude-825097e2:27]. This is why narratives resist premature
+ontology: they don't commit to per-page identity. And why wikis
+struggle: they do.
+
+The brane wiki's trick is to be built on top of an append-only
+substrate it cannot replace. The wiki page can be wrong without
+the record being lost. A page rewrite overwrites the *projection*;
+the narratives underneath still carry the history that produced
+the wrongness.
+
+## Rules of thumb
+
+- **The wiki is not the read path.** The narratives are. The wiki
+  is a navigation layer — useful for orientation, not for truth.
+- **When a wiki page disagrees with a narration, the narration
+  wins.** Update the page; never retrofit the narrative.
+- **Let humans name the pages.** The agent fills; the human
+  carves. Agent-minted pages — where the LLM proposes, names, and
+  schematizes the wiki's ontology unprompted — is the failure mode
+  the Karpathy pattern is most prone to and that this wiki was
+  specifically built to dodge [claude-51cdebff:6].
+- **Cite provenance inline.** If a claim can't name its source,
+  it doesn't belong on the page.
+- **Expect to delete pages.** A wiki that never shrinks has
+  committed to bad ontology and can't admit it. Deletion is a
+  first-class move, not an admission of failure.
+
+## Related
+
+- [premature-ontologies](premature-ontologies.md) — the broader
+  failure-mode this page applies to wiki compilation. Every "where
+  wikis struggle" item here recurs at other layers (schemas, agent
+  memory, knowledge graphs); that page collects the general critique.
+- [sedimentary-superintelligence](sedimentary-superintelligence.md)
+  — the raw substrate underneath. The wiki is a projection of it;
+  the sediment is the thing.
+- [append-only event log](append-only-event-log.md) — the
+  canonical record. No wiki page has equivalent authority.
+- [owning your narratives](owning-your-narratives.md) — the
+  narration-side practice that makes the sediment worth drilling.
+  Wiki pages don't accumulate into sedimentary superintelligence;
+  narrations do.
+- /wiki — the operational protocol that
+  implements the compromise described on this page.

package/.travis.yml

@@ -1,7 +0,0 @@
-language: node_js
-node_js:
-  - "14"
-  - "13"
-  - "12"
-  - "11"
-  - "10"

package/lib/brane.cjs.js

@@ -1,12 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-class Brane {
-    summon(thunk, summoner) {
-        return 0; // TODO
-    }
-}
-
-exports.Brane = Brane;
-//# sourceMappingURL=brane.cjs.js.map

package/lib/brane.cjs.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"brane.cjs.js","sources":["brane.js"],"sourcesContent":["export class Brane {\n    summon(thunk, summoner) {\n        return 0; // TODO\n    }\n}\n//# sourceMappingURL=brane.js.map"],"names":[],"mappings":";;;;AAAO,MAAM,KAAK,CAAC;AACnB,IAAI,MAAM,CAAC,KAAK,EAAE,QAAQ,EAAE;AAC5B,QAAQ,OAAO,CAAC,CAAC;AACjB,KAAK;AACL;;;;"}

package/lib/brane.d.ts

@@ -1,11 +0,0 @@
-declare type AnyFn = (...args: any[]) => any;
-declare type JustMethodKeys<T extends object> = {
-    [key in keyof T]: T[key] extends AnyFn ? key : never;
-}[keyof T];
-export declare type Safe<T> = T extends PromiseLike<infer R> ? Promise<Safe<R>> : T extends (...args: infer A) => infer R ? (...args: A) => Promise<Safe<R>> : T extends object ? {
-    readonly [key in JustMethodKeys<T>]: Safe<T[key]>;
-} : T;
-export declare class Brane {
-    summon<TModule>(thunk: () => PromiseLike<TModule>, summoner?: string): Promise<Safe<TModule>>;
-}
-export {};

package/lib/brane.js

@@ -1,6 +0,0 @@
-export class Brane {
-    summon(thunk, summoner) {
-        return 0; // TODO
-    }
-}
-//# sourceMappingURL=brane.js.map

package/lib/brane.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"brane.js","sourceRoot":"","sources":["../src/brane.ts"],"names":[],"mappings":"AAaA,MAAM,OAAO,KAAK;IACT,MAAM,CACX,KAAiC,EACjC,QAAiB;QAEjB,OAAO,CAAQ,CAAC,CAAC,OAAO;IAC1B,CAAC;CACF"}

package/lib/tests.d.ts

@@ -1 +0,0 @@
-export {};

package/lib/tests.js

@@ -1,8 +0,0 @@
-import assert from "assert";
-import { Brane } from "./brane";
-describe("Brane", function () {
-    it("should be importable", function () {
-        assert.strictEqual(typeof Brane, "function");
-    });
-});
-//# sourceMappingURL=tests.js.map

package/lib/tests.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"tests.js","sourceRoot":"","sources":["../src/tests.ts"],"names":[],"mappings":"AAAA,OAAO,MAAM,MAAM,QAAQ,CAAC;AAC5B,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAEhC,QAAQ,CAAC,OAAO,EAAE;IAChB,EAAE,CAAC,sBAAsB,EAAE;QACzB,MAAM,CAAC,WAAW,CAAC,OAAO,KAAK,EAAE,UAAU,CAAC,CAAC;IAC/C,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC"}

package/rollup.config.js

@@ -1,21 +0,0 @@
-const globals = {
-  __proto__: null,
-  tslib: "tslib",
-};
-
-function external(id) {
-  return id in globals;
-}
-
-export default [{
-  input: "lib/brane.js",
-  external,
-  output: {
-    file: "lib/brane.cjs.js",
-    format: "cjs",
-    exports: "named",
-    sourcemap: true,
-    name: "brane",
-    globals,
-  },
-}];

package/scripts/test.sh

@@ -1,8 +0,0 @@
-#!/usr/bin/env bash
-
-node "$(dirname $0)/../node_modules/.bin/mocha" \
-     --reporter spec \
-     --full-trace \
-     --require esm \
-     --require source-map-support/register \
-     $@

package/src/brane.ts

@@ -1,21 +0,0 @@
-type AnyFn = (...args: any[]) => any
-
-type JustMethodKeys<T extends object> = {
-  [key in keyof T]: T[key] extends AnyFn ? key : never;
-}[keyof T]
-
-export type Safe<T> =
-  T extends PromiseLike<infer R> ? Promise<Safe<R>> :
-  T extends (...args: infer A) => infer R ? (...args: A) => Promise<Safe<R>> :
-  T extends object ? {
-    readonly [key in JustMethodKeys<T>]: Safe<T[key]>;
-  } : T // All primitives types are thread-safe.
-
-export class Brane {
-  public summon<TModule>(
-    thunk: () => PromiseLike<TModule>,
-    summoner?: string,
-  ): Promise<Safe<TModule>> {
-    return 0 as any; // TODO
-  }
-}

package/src/tests.ts

@@ -1,8 +0,0 @@
-import assert from "assert";
-import { Brane } from "./brane";
-
-describe("Brane", function () {
-  it("should be importable", function () {
-    assert.strictEqual(typeof Brane, "function");
-  });
-});

package/tsconfig.json

@@ -1,16 +0,0 @@
-{
-  "compilerOptions": {
-    "rootDir": "./src",
-    "outDir": "./lib",
-    "lib": ["dom", "es2015"],
-    "target": "es2015",
-    "module": "es2015",
-    "importHelpers": true,
-    "declaration": true,
-    "sourceMap": true,
-    "types": ["node", "mocha"],
-    "strict": true,
-    "noImplicitAny": true,
-    "esModuleInterop": true
-  }
-}