# 🟢 Beginner examples

**41 saved lessons.** Follow their order or choose a topic that answers your question.

[Open the Beginner guide](../../beginner/index.md) · [All examples](../index.md)

<ul class="example-list">
<li class="example-item" data-level="beginner" data-topics="[&quot;Registration&quot;, &quot;Resolution&quot;]" data-search="hello melder the sixty-second first contact - bind one class, conjure a conduit, meld an instance. the whole dgr in four lines. md.spellbook, md.existence, md.conduit (returned type) registration resolution"><span class="example-level">🟢 Beginner · 01</span><h3><a href="../hello-melder.html">Hello Melder</a></h3><p>The sixty-second first contact - bind one class, conjure a conduit, meld an instance. The whole DGR in four lines.</p><div><span class="example-topic">Registration</span><span class="example-topic">Resolution</span></div></li>
<li class="example-item" data-level="beginner" data-topics="[&quot;Registration&quot;, &quot;Resolution&quot;]" data-search="lifecycles unique vs many the one decision every binding makes - where does instance reuse stop? unique = one shared instance; many = fresh construction per meld. this is existence, the heart of the bind vocabulary. md.spellbook, existence=&quot;unique&quot; / &quot;many&quot; registration resolution"><span class="example-level">🟢 Beginner · 02</span><h3><a href="02-lifecycles-unique-vs-many.html">Lifecycles unique vs many</a></h3><p>The one decision every binding makes - where does instance reuse stop? unique = one shared instance; many = fresh construction per meld. This is Existence, the heart of the bind vocabulary.</p><div><span class="example-topic">Registration</span><span class="example-topic">Resolution</span></div></li>
<li class="example-item" data-level="beginner" data-topics="[&quot;Registration&quot;]" data-search="bind functions and instances spells are not only classes - functions and ready-made objects bind with the same verb. runtime law (proven by the harness): callable and pre-built spells are always &quot;unique&quot; - the factory runs once and its product is shared; instances are already built. function spells, instance spells, string vocabulary registration"><span class="example-level">🟢 Beginner · 03</span><h3><a href="03-bind-functions-and-instances.html">Bind functions and instances</a></h3><p>Spells are not only classes - functions and ready-made objects bind with the same verb. RUNTIME LAW (proven by the harness): callable and pre-built spells are always &quot;unique&quot; - the factory…</p><div><span class="example-topic">Registration</span></div></li>
<li class="example-item" data-level="beginner" data-topics="[&quot;Registration&quot;, &quot;Resolution&quot;]" data-search="named bindings two implementations of one shape, told apart by binding_name - the beginner door into disambiguation (spellframes come later). md.spellbook, md.existence, binding_name= on bind/meld registration resolution"><span class="example-level">🟢 Beginner · 04</span><h3><a href="04-named-bindings.html">Named bindings</a></h3><p>Two implementations of one shape, told apart by binding_name - the beginner door into disambiguation (spellframes come later).</p><div><span class="example-topic">Registration</span><span class="example-topic">Resolution</span></div></li>
<li class="example-item" data-level="beginner" data-topics="[]" data-search="lesser conduit scopes scopes without ceremony - a lesser conduit is a child resolution scope; unique_per_conduit gives each scope its own instance while plain unique stays shared across the family. md.spellbook, md.existence.unique_per_conduit, md.conduit.create_lesser_conduit"><span class="example-level">🟢 Beginner · 05</span><h3><a href="05-lesser-conduit-scopes.html">Lesser conduit scopes</a></h3><p>Scopes without ceremony - a lesser conduit is a child resolution scope; unique_per_conduit gives each scope its own instance while plain unique stays shared across the family.</p><div></div></li>
<li class="example-item" data-level="beginner" data-topics="[&quot;Resolution&quot;]" data-search="error vocabulary failing well on day one - every exception melder raises at you is catchable from the root namespace. no internal paths, ever. md.spellbookvalidationerror, md.meldexecutionerror resolution"><span class="example-level">🟢 Beginner · 06</span><h3><a href="06-error-vocabulary.html">Error vocabulary</a></h3><p>Failing well on day one - every exception melder raises at you is catchable from the root namespace. No internal paths, ever.</p><div><span class="example-topic">Resolution</span></div></li>
<li class="example-item" data-level="beginner" data-topics="[&quot;Registration&quot;, &quot;Resolution&quot;, &quot;Lifetimes &amp; cleanup&quot;, &quot;Configuration&quot;]" data-search="strings as vocabulary the vocabulary enums all accept their string names too - config files and cli flags can drive registration without importing the enums. both spellings resolve to the same lifecycles. md.spellbook.bind, md.spellbook.conjure, md.existence.many, md.conduit.meld registration resolution lifetimes &amp; cleanup configuration"><span class="example-level">🟢 Beginner · 07</span><h3><a href="07-strings-as-vocabulary.html">Strings as vocabulary</a></h3><p>The vocabulary enums all accept their string names too - config files and CLI flags can drive registration without importing the enums. Both spellings resolve to the same lifecycles.</p><div><span class="example-topic">Registration</span><span class="example-topic">Resolution</span><span class="example-topic">Lifetimes &amp; cleanup</span><span class="example-topic">Configuration</span></div></li>
<li class="example-item" data-level="beginner" data-topics="[&quot;Registration&quot;, &quot;Resolution&quot;, &quot;Lifetimes &amp; cleanup&quot;]" data-search="disposal contract teardown is part of registration - disposal_method_names tells melder which methods to call on your instances when their owner cleans up. no base class, no protocol: name the method, done. the printed stages document exactly when disposal fires. bind(disposal_method_names=[...]), cleanup cascade registration resolution lifetimes &amp; cleanup"><span class="example-level">🟢 Beginner · 08</span><h3><a href="08-disposal-contract.html">Disposal contract</a></h3><p>Teardown is part of registration - disposal_method_names tells melder which methods to call on YOUR instances when their owner cleans up. No base class, no protocol: name the method, done.…</p><div><span class="example-topic">Registration</span><span class="example-topic">Resolution</span><span class="example-topic">Lifetimes &amp; cleanup</span></div></li>
<li class="example-item" data-level="beginner" data-topics="[&quot;Registration&quot;, &quot;Resolution&quot;]" data-search="spellframe grouping spellframes are the grouping key above binding names - one frame key collects a family of related bindings, and (spellframe, binding_name) is the full lookup address. bind(spellframe=...), meld(spellframe=..., binding_name=...) registration resolution"><span class="example-level">🟢 Beginner · 09</span><h3><a href="09-spellframe-grouping.html">Spellframe grouping</a></h3><p>Spellframes are the grouping key above binding names - one frame key collects a family of related bindings, and (spellframe, binding_name) is the full lookup address.</p><div><span class="example-topic">Registration</span><span class="example-topic">Resolution</span></div></li>
<li class="example-item" data-level="beginner" data-topics="[&quot;Lifetimes &amp; cleanup&quot;]" data-search="explicit cleanup teardown is a verb you own - conduit.cleanup() then book.cleanup(), in that order, and a cleaned book refuses further work loudly. (disposal hooks you registered fire during this walk - see 08/35.) cleanup verbs, post-cleanup guards lifetimes &amp; cleanup"><span class="example-level">🟢 Beginner · 10</span><h3><a href="10-explicit-cleanup.html">Explicit cleanup</a></h3><p>Teardown is a verb you own - conduit.cleanup() then book.cleanup(), in that order, and a cleaned book refuses further work loudly. (Disposal hooks you registered fire during this walk - see…</p><div><span class="example-topic">Lifetimes &amp; cleanup</span></div></li>
<li class="example-item" data-level="beginner" data-topics="[&quot;Registration&quot;]" data-search="bind many at once registration is just python - bind a whole list of classes with a plain loop. no special batch api needed, ever. bind() in a loop registration"><span class="example-level">🟢 Beginner · 11</span><h3><a href="11-bind-many-at-once.html">Bind many at once</a></h3><p>Registration is just Python - bind a whole list of classes with a plain loop. No special batch API needed, ever.</p><div><span class="example-topic">Registration</span></div></li>
<li class="example-item" data-level="beginner" data-topics="[&quot;Resolution&quot;, &quot;Agent rooms &amp; codegen&quot;]" data-search="agent first read an agent&#x27;s first sixty seconds with melder: read the workflow map from help(), read the version, then open the hardcopy system docs the package carries about itself. no filesystem, no web - the library is its own documentation. md.__doc__, md.__version__, md.__all__, md.__architecture__, md.__components__, md.__graph_network__, md.__graph_details__ resolution agent rooms &amp; codegen"><span class="example-level">🟢 Beginner · 12</span><h3><a href="12-agent-first-read.html">Agent first read</a></h3><p>An agent&#x27;s first sixty seconds with melder: read the workflow map from help(), read the version, then open the hardcopy system docs the package carries about itself. No filesystem, no web -…</p><div><span class="example-topic">Resolution</span><span class="example-topic">Agent rooms &amp; codegen</span></div></li>
<li class="example-item" data-level="beginner" data-topics="[]" data-search="existence unique unique, studied closely - one instance for the whole world: root conduit, child scopes, everywhere. the widest sharing mode. md.existence.unique"><span class="example-level">🟢 Beginner · 13</span><h3><a href="13-existence-unique.html">Existence unique</a></h3><p>unique, studied closely - ONE instance for the whole world: root conduit, child scopes, everywhere. The widest sharing mode.</p><div></div></li>
<li class="example-item" data-level="beginner" data-topics="[&quot;Resolution&quot;, &quot;Lifetimes &amp; cleanup&quot;]" data-search="existence many many, studied closely - construction every meld, no caching anywhere. the mode for request-shaped, disposable things. md.existence.many resolution lifetimes &amp; cleanup"><span class="example-level">🟢 Beginner · 14</span><h3><a href="14-existence-many.html">Existence many</a></h3><p>many, studied closely - construction EVERY meld, no caching anywhere. The mode for request-shaped, disposable things.</p><div><span class="example-topic">Resolution</span><span class="example-topic">Lifetimes &amp; cleanup</span></div></li>
<li class="example-item" data-level="beginner" data-topics="[]" data-search="existence unique per conduit unique_per_conduit - each conduit scope holds its own single instance; stable inside the scope, separate across scopes. md.existence.unique_per_conduit"><span class="example-level">🟢 Beginner · 15</span><h3><a href="15-existence-unique-per-conduit.html">Existence unique per conduit</a></h3><p>unique_per_conduit - each conduit scope holds its OWN single instance; stable inside the scope, separate across scopes.</p><div></div></li>
<li class="example-item" data-level="beginner" data-topics="[&quot;Resolution&quot;, &quot;Agent rooms &amp; codegen&quot;]" data-search="typed melding type hints and melding are friends - annotate what you meld and your editor (and your agent) knows every attribute from there on. melder ships py.typed, so checkers see real types, not any. meld with annotations, the typed root namespace resolution agent rooms &amp; codegen"><span class="example-level">🟢 Beginner · 16</span><h3><a href="16-typed-melding.html">Typed melding</a></h3><p>Type hints and melding are friends - annotate what you meld and your editor (and your agent) knows every attribute from there on. melder ships py.typed, so checkers see real types, not Any.</p><div><span class="example-topic">Resolution</span><span class="example-topic">Agent rooms &amp; codegen</span></div></li>
<li class="example-item" data-level="beginner" data-topics="[&quot;Registration&quot;, &quot;Resolution&quot;, &quot;Inspection&quot;]" data-search="protocols as shapes protocols describe a shape; bindings fill it - two implementations of one protocol, chosen by binding name, called through the shared shape. static duck typing meets dependency injection, gently. typing.protocol + named bindings registration resolution inspection"><span class="example-level">🟢 Beginner · 17</span><h3><a href="17-protocols-as-shapes.html">Protocols as shapes</a></h3><p>Protocols describe a SHAPE; bindings fill it - two implementations of one Protocol, chosen by binding name, called through the shared shape. Static duck typing meets dependency injection,…</p><div><span class="example-topic">Registration</span><span class="example-topic">Resolution</span><span class="example-topic">Inspection</span></div></li>
<li class="example-item" data-level="beginner" data-topics="[&quot;Registration&quot;, &quot;Resolution&quot;, &quot;Configuration&quot;]" data-search="bootstrap pattern the composition root - one function that binds the whole world and hands back the conduit. configured things are built there and bound as instances; everything else in the app just melds. note: melder worlds do not &quot;switch environments&quot; - the same objects cannot register twice (a spell_id is the sha256 of an object&#x27;s code and data), so your module decides what to build, once, at the root. the build_world() pattern, instance spells registration resolution configuration"><span class="example-level">🟢 Beginner · 18</span><h3><a href="18-bootstrap-pattern.html">Bootstrap pattern</a></h3><p>The composition root - ONE function that binds the whole world and hands back the conduit. Configured things are BUILT there and bound as instances; everything else in the app just melds.…</p><div><span class="example-topic">Registration</span><span class="example-topic">Resolution</span><span class="example-topic">Configuration</span></div></li>
<li class="example-item" data-level="beginner" data-topics="[&quot;Lifetimes &amp; cleanup&quot;]" data-search="lifecycle map the whole beginner lifecycle vocabulary on one page. three modes answer one question - where does instance reuse stop? - and three is enough to build real things. (three more exist for bigger worlds; they live in the later tiers.) md.existence.unique / many / unique_per_conduit lifetimes &amp; cleanup"><span class="example-level">🟢 Beginner · 19</span><h3><a href="19-lifecycle-map.html">Lifecycle map</a></h3><p>The whole beginner lifecycle vocabulary on one page. Three modes answer one question - where does instance reuse stop? - and three is enough to build real things. (Three more exist for…</p><div><span class="example-topic">Lifetimes &amp; cleanup</span></div></li>
<li class="example-item" data-level="beginner" data-topics="[&quot;Resolution&quot;, &quot;Configuration&quot;]" data-search="defaults just work your constructor defaults are the configuration - a class with default arguments melds without any extra setup. melder calls your __init__; python fills the defaults. plain constructor defaults through meld resolution configuration"><span class="example-level">🟢 Beginner · 20</span><h3><a href="20-defaults-just-work.html">Defaults just work</a></h3><p>Your constructor defaults ARE the configuration - a class with default arguments melds without any extra setup. melder calls YOUR __init__; Python fills the defaults.</p><div><span class="example-topic">Resolution</span><span class="example-topic">Configuration</span></div></li>
<li class="example-item" data-level="beginner" data-topics="[&quot;Registration&quot;, &quot;Resolution&quot;]" data-search="the basic rhythm the rhythm of every melder program: bind everything first, conjure once, meld everywhere after. three verbs, one order. the bind -&gt; conjure -&gt; meld order registration resolution"><span class="example-level">🟢 Beginner · 21</span><h3><a href="21-the-basic-rhythm.html">The basic rhythm</a></h3><p>The rhythm of every melder program: bind everything FIRST, conjure ONCE, meld everywhere after. Three verbs, one order.</p><div><span class="example-topic">Registration</span><span class="example-topic">Resolution</span></div></li>
<li class="example-item" data-level="beginner" data-topics="[&quot;Registration&quot;, &quot;Research &amp; change&quot;]" data-search="same name different frames binding_name is a sub-key - the same name under two different frames is two different addresses. (frame, name) is always the full address; names never collide across frames. the (frame, name) address space registration research &amp; change"><span class="example-level">🟢 Beginner · 22</span><h3><a href="22-same-name-different-frames.html">Same name different frames</a></h3><p>binding_name is a SUB-key - the same name under two different frames is two different addresses. (frame, name) is always the full address; names never collide across frames.</p><div><span class="example-topic">Registration</span><span class="example-topic">Research &amp; change</span></div></li>
<li class="example-item" data-level="beginner" data-topics="[&quot;Resolution&quot;, &quot;Connections&quot;]" data-search="reading the errors the three mistakes everyone makes in hour one, and what melder says back. learn the error shapes once and debugging is easy. the beginner error contracts (all run-proven) resolution connections"><span class="example-level">🟢 Beginner · 23</span><h3><a href="23-reading-the-errors.html">Reading the errors</a></h3><p>The three mistakes everyone makes in hour one, and what melder says back. Learn the error shapes once and debugging is easy.</p><div><span class="example-topic">Resolution</span><span class="example-topic">Connections</span></div></li>
<li class="example-item" data-level="beginner" data-topics="[&quot;Registration&quot;, &quot;Lifetimes &amp; cleanup&quot;, &quot;Connections&quot;, &quot;Research &amp; change&quot;]" data-search="same class many names one class, one spell - a spell_id is the sha256 of the class&#x27;s code, so the same class registers once, whatever binding name or lifecycle you give it (beginner 30). the working pattern for one shape in many roles: tiny subclasses, one per role - each is a new class, so its own spell, at its own address. (same-named classes with different code may also coexist at different addresses since 0.2.8206; the contract probes pin both rules.) subclass-per-role registration, mixed lifecycles registration lifetimes &amp; cleanup connections research &amp; change"><span class="example-level">🟢 Beginner · 24</span><h3><a href="24-same-class-many-names.html">Same class many names</a></h3><p>One class, one spell - a spell_id is the SHA256 of the class&#x27;s code, so the SAME class registers once, whatever binding name or lifecycle you give it (beginner 30). The working pattern for…</p><div><span class="example-topic">Registration</span><span class="example-topic">Lifetimes &amp; cleanup</span><span class="example-topic">Connections</span><span class="example-topic">Research &amp; change</span></div></li>
<li class="example-item" data-level="beginner" data-topics="[&quot;Registration&quot;, &quot;Connections&quot;]" data-search="frames as dict classification spellframes are categories. organize one world&#x27;s spells by the resolution ideas your app already has - &quot;repositories&quot;, &quot;notifiers&quot; - and (category, name) becomes the full address. the addressing feels like a two-level dict, but frames are not dicts: they are grouping and contract keys. a string frame groups; a protocol frame also validates what binds under it (intermediate tier). seed for later: when a category needs its own owner and its own resolution conditions, the category graduates into a whole conduit - that story is intermediate lesson 26. spellframe + binding_name as a category address space registration connections"><span class="example-level">🟢 Beginner · 25</span><h3><a href="25-frames-as-dict-classification.html">Frames as dict classification</a></h3><p>Spellframes are CATEGORIES. Organize one world&#x27;s spells by the resolution ideas your app already has - &quot;repositories&quot;, &quot;notifiers&quot; - and (category, name) becomes the full address. The…</p><div><span class="example-topic">Registration</span><span class="example-topic">Connections</span></div></li>
<li class="example-item" data-level="beginner" data-topics="[&quot;Registration&quot;, &quot;Resolution&quot;]" data-search="meld address forms the address law (run-proven + doc-canon): every spell lives at one (frame_key, binding_key) address - frame_key is your spellframe, or the spell&#x27;s normalized name if you gave none; binding_key is your binding_name, or the default slot. human callers use a quoted spell name; machine callers use an explicit spell_id. a categorized registration also has a complete (spellframe, binding_name) address. a name alone does not supply a custom spellframe. meld(&quot;spellname&quot;), meld(spell_id=...), meld(spellframe=..., binding_name=...) registration resolution"><span class="example-level">🟢 Beginner · 26</span><h3><a href="26-meld-address-forms.html">Meld address forms</a></h3><p>THE ADDRESS LAW (run-proven + doc-canon): every spell lives at one (frame_key, binding_key) address - frame_key is your spellframe, or the spell&#x27;s normalized name if you gave none;…</p><div><span class="example-topic">Registration</span><span class="example-topic">Resolution</span></div></li>
<li class="example-item" data-level="beginner" data-topics="[]" data-search="pass the conduit around app structure 101 - main() owns the conduit and passes it to the functions that need things. don&#x27;t re-conjure, don&#x27;t stash globals: the conduit is the world handle, hand it around like one. the conduit as an argument"><span class="example-level">🟢 Beginner · 27</span><h3><a href="27-pass-the-conduit-around.html">Pass the conduit around</a></h3><p>App structure 101 - main() owns the conduit and PASSES it to the functions that need things. Don&#x27;t re-conjure, don&#x27;t stash globals: the conduit is the world handle, hand it around like one.</p><div></div></li>
<li class="example-item" data-level="beginner" data-topics="[&quot;Resolution&quot;]" data-search="real objects no wrappers melded objects are your objects - no proxies, no wrappers, no magic subclasses. what comes back is the instance: identity checks hold, isinstance holds, and it works everywhere a plain object works. many di containers wrap; melder hands you the real thing. instance identity through meld resolution"><span class="example-level">🟢 Beginner · 28</span><h3><a href="28-real-objects-no-wrappers.html">Real objects no wrappers</a></h3><p>Melded objects are YOUR objects - no proxies, no wrappers, no magic subclasses. What comes back IS the instance: identity checks hold, isinstance holds, and it works everywhere a plain…</p><div><span class="example-topic">Resolution</span></div></li>
<li class="example-item" data-level="beginner" data-topics="[&quot;Resolution&quot;]" data-search="many state isolation &quot;many&quot; means isolated - each melded instance owns its own state; mutating one never leaks into the next. the confusion this example prevents: expecting fresh objects to share anything. md.existence &quot;many&quot; state isolation resolution"><span class="example-level">🟢 Beginner · 29</span><h3><a href="29-many-state-isolation.html">Many state isolation</a></h3><p>&quot;many&quot; means ISOLATED - each melded instance owns its own state; mutating one never leaks into the next. The confusion this example prevents: expecting fresh objects to share anything.</p><div><span class="example-topic">Resolution</span></div></li>
<li class="example-item" data-level="beginner" data-topics="[&quot;Registration&quot;, &quot;Lifetimes &amp; cleanup&quot;]" data-search="double bind outcome binding the same class twice is refused - a spell_id is the sha256 of the class&#x27;s code, and one object registers once, under any binding name or lifecycle. when one shape must serve two roles, make two shapes: subclass it (see 24). the one-object law at bind time registration lifetimes &amp; cleanup"><span class="example-level">🟢 Beginner · 30</span><h3><a href="30-double-bind-outcome.html">Double bind outcome</a></h3><p>Binding the SAME class twice is refused - a spell_id is the SHA256 of the class&#x27;s code, and one object registers once, under any binding name or lifecycle. When one shape must serve two…</p><div><span class="example-topic">Registration</span><span class="example-topic">Lifetimes &amp; cleanup</span></div></li>
<li class="example-item" data-level="beginner" data-topics="[&quot;Registration&quot;, &quot;Resolution&quot;]" data-search="required vocabulary existence is not optional - the bind vocabulary is explicit by design. forgetting it fails loudly at bind time, not quietly at meld time. the error type is printed for the record. bind() required kwargs, fail-fast law registration resolution"><span class="example-level">🟢 Beginner · 31</span><h3><a href="31-required-vocabulary.html">Required vocabulary</a></h3><p>existence is not optional - the bind vocabulary is explicit by design. Forgetting it fails LOUDLY at bind time, not quietly at meld time. The error type is printed for the record.</p><div><span class="example-topic">Registration</span><span class="example-topic">Resolution</span></div></li>
<li class="example-item" data-level="beginner" data-topics="[&quot;Resolution&quot;]" data-search="factory functions two factory shapes, one law each - a function spell is unique (one shared product); when you want a fresh object per meld, the factory must be a class bound &quot;many&quot;. function-unique law vs class-many freshness resolution"><span class="example-level">🟢 Beginner · 32</span><h3><a href="32-factory-functions.html">Factory functions</a></h3><p>Two factory shapes, one law each - a FUNCTION spell is unique (one shared product); when you want a fresh object per meld, the factory must be a CLASS bound &quot;many&quot;.</p><div><span class="example-topic">Resolution</span></div></li>
<li class="example-item" data-level="beginner" data-topics="[&quot;Registration&quot;]" data-search="prebuilt registry a registry of ready-made same-typed objects. spell names must be unique per book (probe-proven), so n instances of one class bind as one registry spell - the dict is the spell, lookup stays yours. collection-as-instance-spell, read permission registration"><span class="example-level">🟢 Beginner · 33</span><h3><a href="33-prebuilt-registry.html">Prebuilt registry</a></h3><p>A registry of ready-made same-typed objects. Spell names must be unique per book (probe-proven), so N instances of one class bind as ONE registry spell - the dict is the spell, lookup stays…</p><div><span class="example-topic">Registration</span></div></li>
<li class="example-item" data-level="beginner" data-topics="[]" data-search="scope contrast one tree unique vs unique_per_conduit in the same conduit tree - the side-by-side that makes scope reach click. md.existence.unique vs unique_per_conduit contrast"><span class="example-level">🟢 Beginner · 34</span><h3><a href="34-scope-contrast-one-tree.html">Scope contrast one tree</a></h3><p>unique vs unique_per_conduit in the SAME conduit tree - the side-by-side that makes scope reach click.</p><div></div></li>
<li class="example-item" data-level="beginner" data-topics="[&quot;Registration&quot;, &quot;Lifetimes &amp; cleanup&quot;]" data-search="disposal multiple methods disposal_method_names takes a list - complex resources name every teardown verb they need, and the printed order documents how the runtime walks them. bind(disposal_method_names=[&quot;flush&quot;, &quot;close&quot;]) registration lifetimes &amp; cleanup"><span class="example-level">🟢 Beginner · 35</span><h3><a href="35-disposal-multiple-methods.html">Disposal multiple methods</a></h3><p>disposal_method_names takes a LIST - complex resources name every teardown verb they need, and the printed order documents how the runtime walks them.</p><div><span class="example-topic">Registration</span><span class="example-topic">Lifetimes &amp; cleanup</span></div></li>
<li class="example-item" data-level="beginner" data-topics="[]" data-search="one book one conduit one book conjures one conduit, ever (probe-proven: a second conjure raises runtimeerror). multiple scopes come from lesser conduits; multiple roots come from multiple books. the single-conjure law, lesser conduits, second book"><span class="example-level">🟢 Beginner · 36</span><h3><a href="36-one-book-one-conduit.html">One book one conduit</a></h3><p>One book conjures ONE conduit, ever (probe-proven: a second conjure raises RuntimeError). Multiple scopes come from lesser conduits; multiple roots come from multiple books.</p><div></div></li>
<li class="example-item" data-level="beginner" data-topics="[&quot;Registration&quot;, &quot;Lifetimes &amp; cleanup&quot;]" data-search="bind vocabulary cheatsheet the whole bind vocabulary on one page - every kwarg a beginner will meet, printed as a cheatsheet next to a registration that uses all of them at once. bind(spell, existence, permissions, spellframe, binding_name, disposal_method_names, profile, **kwargs) registration lifetimes &amp; cleanup"><span class="example-level">🟢 Beginner · 37</span><h3><a href="37-bind-vocabulary-cheatsheet.html">Bind vocabulary cheatsheet</a></h3><p>The whole bind vocabulary on one page - every kwarg a beginner will meet, printed as a cheatsheet next to a registration that uses ALL of them at once.</p><div><span class="example-topic">Registration</span><span class="example-topic">Lifetimes &amp; cleanup</span></div></li>
<li class="example-item" data-level="beginner" data-topics="[&quot;Resolution&quot;]" data-search="meld a frame as dict closing the dict-style loop - a small helper melds a whole frame family into a plain {name: instance} dict, because the (frame, name) address space maps 1:1 onto the dicts users already think in. frame-family melding, dict-style consumption resolution"><span class="example-level">🟢 Beginner · 38</span><h3><a href="38-meld-a-frame-as-dict.html">Meld a frame as dict</a></h3><p>Closing the dict-style loop - a small helper melds a whole frame family into a plain {name: instance} dict, because the (frame, name) address space maps 1:1 onto the dicts users already…</p><div><span class="example-topic">Resolution</span></div></li>
<li class="example-item" data-level="beginner" data-topics="[&quot;Registration&quot;, &quot;Inspection&quot;, &quot;Agent rooms &amp; codegen&quot;]" data-search="agent inventory pattern an agent classifying the library itself - walk md.__all__ and sort every name into callable vocabulary vs types vs errors vs metadata, producing the machine-readable inventory an agent builds before its first bind. md.__all__, the whole root namespace, issubclass checks registration inspection agent rooms &amp; codegen"><span class="example-level">🟢 Beginner · 39</span><h3><a href="39-agent-inventory-pattern.html">Agent inventory pattern</a></h3><p>An agent classifying the library itself - walk md.__all__ and sort every name into callable vocabulary vs types vs errors vs metadata, producing the machine-readable inventory an agent…</p><div><span class="example-topic">Registration</span><span class="example-topic">Inspection</span><span class="example-topic">Agent rooms &amp; codegen</span></div></li>
<li class="example-item" data-level="beginner" data-topics="[&quot;Registration&quot;, &quot;Resolution&quot;, &quot;Lifetimes &amp; cleanup&quot;]" data-search="beginner capstone build and use a small application across separate python modules: ordinary objects, one bootstrap, a type_checking consumer, constructor injection, shared resources, fresh handlers, and explicit cleanup. each bind manages its own transaction; no outer book lock is needed. md.spellbook.bind/conjure, md.conduit.meld/cleanup, unique/many, constructor injection, disposal_method_names registration resolution lifetimes &amp; cleanup"><span class="example-level">🟢 Beginner · 40</span><h3><a href="40-beginner-capstone.html">Beginner capstone</a></h3><p>Build and use a small application across separate Python modules: ordinary objects, one bootstrap, a TYPE_CHECKING consumer, constructor injection, shared resources, fresh handlers, and…</p><div><span class="example-topic">Registration</span><span class="example-topic">Resolution</span><span class="example-topic">Lifetimes &amp; cleanup</span></div></li>
<li class="example-item" data-level="beginner" data-topics="[&quot;Resolution&quot;, &quot;Lifetimes &amp; cleanup&quot;]" data-search="you own the memory now you own the memory now - not the gc. a di runtime holds what it builds: your `unique` instance lives in the conduit&#x27;s creations store, so dropping your variable frees nothing - python&#x27;s garbage collector cannot collect what the world still references. this is the trade every di-style tool makes: the runtime manages your objects, so you must end their lifecycles. cleanup() is not ceremony - it is how memory comes back. this lesson proves it with a weakref (a watcher that answers &quot;is the object still alive?&quot; without keeping it alive). the lifecycle law - meld, del, cleanup, and who really holds the object resolution lifetimes &amp; cleanup"><span class="example-level">🟢 Beginner · 41</span><h3><a href="41-you-own-the-memory-now.html">You own the memory now</a></h3><p>YOU own the memory now - not the GC. A DI runtime HOLDS what it builds: your `unique` instance lives in the conduit&#x27;s creations store, so dropping YOUR variable frees nothing - Python&#x27;s…</p><div><span class="example-topic">Resolution</span><span class="example-topic">Lifetimes &amp; cleanup</span></div></li>
</ul>

```{toctree}
:hidden:

Hello Melder <../hello-melder>
Lifecycles unique vs many <02-lifecycles-unique-vs-many>
Bind functions and instances <03-bind-functions-and-instances>
Named bindings <04-named-bindings>
Lesser conduit scopes <05-lesser-conduit-scopes>
Error vocabulary <06-error-vocabulary>
Strings as vocabulary <07-strings-as-vocabulary>
Disposal contract <08-disposal-contract>
Spellframe grouping <09-spellframe-grouping>
Explicit cleanup <10-explicit-cleanup>
Bind many at once <11-bind-many-at-once>
Agent first read <12-agent-first-read>
Existence unique <13-existence-unique>
Existence many <14-existence-many>
Existence unique per conduit <15-existence-unique-per-conduit>
Typed melding <16-typed-melding>
Protocols as shapes <17-protocols-as-shapes>
Bootstrap pattern <18-bootstrap-pattern>
Lifecycle map <19-lifecycle-map>
Defaults just work <20-defaults-just-work>
The basic rhythm <21-the-basic-rhythm>
Same name different frames <22-same-name-different-frames>
Reading the errors <23-reading-the-errors>
Same class many names <24-same-class-many-names>
Frames as dict classification <25-frames-as-dict-classification>
Meld address forms <26-meld-address-forms>
Pass the conduit around <27-pass-the-conduit-around>
Real objects no wrappers <28-real-objects-no-wrappers>
Many state isolation <29-many-state-isolation>
Double bind outcome <30-double-bind-outcome>
Required vocabulary <31-required-vocabulary>
Factory functions <32-factory-functions>
Prebuilt registry <33-prebuilt-registry>
Scope contrast one tree <34-scope-contrast-one-tree>
Disposal multiple methods <35-disposal-multiple-methods>
One book one conduit <36-one-book-one-conduit>
Bind vocabulary cheatsheet <37-bind-vocabulary-cheatsheet>
Meld a frame as dict <38-meld-a-frame-as-dict>
Agent inventory pattern <39-agent-inventory-pattern>
Beginner capstone <40-beginner-capstone>
You own the memory now <41-you-own-the-memory-now>
```