Every page of this manual ends with the questions its subject leaves open. This page gathers them in one place, grouped by the part of the manual where each is first raised. A question raised on several pages appears once, under the first, with a link to every page that raises it; each link goes to that page's Open questions section. The last group lists what writing the worked examples found, linking to each example's account of it. Each entry is a summary: the page has the question in full. Where a proposal now answers a question, the entry says so and links the proposal; the question stays here until the proposal is reviewed.

Introduction

• The encoding. Whether ConeScript is finally written as a layer of Cone or as a notation of its own, decided once the requirements are settled. (What ConeScript is)
• Shorthand. The language starts with plain functions and named options only. Which forms earn a shorter spelling, once use shows where it helps: the most frequent are a part's material and place, a field's range and options, and joining a shape's pieces built in a loop. (Introduction: minimal forms first)
• Language or vocabulary. Which of the ten differences from a program are rules of the language (distribution, purity) and which could be library (clocks and frames as types). (What ConeScript is)
• The ceiling on world logic. How far a world's own designs may go before a capability belongs in a package; a rule, or at least a test, for which side of the line a function falls; a hand-written follower and per-point gullies as cases. (What ConeScript is, Package behaviors, Open functions, Packages)

Part 1. Fundamentals

• Integers. A counting type apart from number, or integer-ness as a property of a range. A proposal answers this: the type count (Values: counts). (Values)
• Out of range. What happens when a value written to a field falls outside its stated range: refused, clamped or reported. (Values)
• Moments and their clock. Whether a moment carries the clock it was read on, so mixing clocks is refused; whether never is a moment or an empty option. (Values)
• Which clock a view's own smoothing counts. The sound's shelter chase is about the person's hearing, which argues for real time. (Values, Animators, Sounds)
• Steps as time. "Four steps" of the simulation had to become sim(0.067 s). (Values, Animators)
• A clock running backward. What an animator that has ended does when the clock runs back past its end. (Values)
• Types used but not defined. Place, point and direction as one type under several names (proposed) or separate types (an offset is defined: a place difference); the type of a region; a set of beings; moments, enums and keyed tables as field types. (Values, Fields)
• Colors in other spaces. srgb 0 to 255, srgbFraction 0 to 1 and linear color are proposed, with mix(..., in: srgb); whether a temperature or a wider gamut need spellings. (Values)
• What a being handle is. A reference to "a being in the world" that can be stored, compared, keyed and measured; what happens to its rows when the being goes away; its own type with tests such as "driven by a visitor", beings under a root content may query, or relations only; and how to say "a being a person drives" without saying which person. (Values, Visitors)
• Lifetimes of keyed values. Whether a keyed field can declare its lifetime ("while below", "until the exit") instead of a handler clearing it. (Values, Fields)
• Keys other than beings. Tables keyed by a part or a camera. (Values)
• Results and throw. Whether world logic needs Cone's results, and the clash of throw as an error return with throw as a world action that sets a ball rolling. (Values, Actions)
• Constructor arguments. Positional or named. A proposal answers this: a design's fields without a default may be given by position or by name, those with one by name (Expressions: the argument rule). (Expressions, Construction)
• Operands in order. The maths functions and color makers take two or three values in order (min(a, b), mix(a, b, t), srgb(r, g, b)), as do set, say and keys. A proposal answers this: required parameters may be given by position, in declared order; only parameters with a default must be named (Expressions: the argument rule). (Expressions)
• Hyphens in names. Names now follow Cone's rules, in camelCase; whether names should allow hyphens (as CSS and Lisp do, with spaces round a minus) stays open: readability against Cone compatibility. (Expressions)
• % as remainder and as share. rate(99%, per: sim(0.35 s)) against Cone's remainder; separated by context, untested. (Expressions, Animators)
• Namespacing. Whether qualifiers are package names (npcbehave.patrol) or the vocabulary's own (shape tools are written bare, lathe); the 2-D element names are placeholders under the same question. A clash with a world's own name is settled: a local name hides a tool, and the tool is still reached through its package (sculpt.face). (Construction, Layouts, Packages)
• Derivation. A relation of its own, or a consequence of expressions that mention other parts; ConeScript now writes it explicitly as derive. (Expressions, Subscriptions)
• Which observations a value block may make. A debug log, yes; a counter or a timing a later rule could read is no longer an observation. (Blocks, Subscriptions)
• The hiding rule's precise form. A local may not reuse a name its own right-hand side, or a later line of the block, reads from outside. (Blocks)
• The bracket-free list form of on. Whether on(trigger, action, action) is kept, or every handler with more than one action is a braced block; and whether a handler may stop early with return. (Blocks, Events)
• Functions that act. Allowed and callable only from acting blocks, or never, with acts only in on(...). (Functions)
• What a closure captures without borrowing, and whether it may hold changing state. (Functions)
• Defaults from fields. Whether a parameter's default may read the part's fields. (Functions)
• Where logic that spans parts lives, and what it may read. The riddle puts it on the common parent; whether a part's function may read its children's, its siblings' or a server-only field; the rule that a server field may be read only by logic that runs on the server, stated precisely. (Functions, Distribution)
• World-defined pipeline steps. Whether a world may define its own steps, math only, that interoperate with the vocabulary's tools and are compiled and loaded with the world. (Functions, Construction, Open functions, Packages)
• while over time. A "while X, do Y" that expands to an entry and an exit, once the pair has been tried on more cases; and the clash with Cone's while loop, a different thing under the same word. (Control flow, Events)
• Ranging over beings: closed. A condition over beings is written each v in visitors around the rule, Cone's loop (Events). (Control flow, Visitors)
• State machines cost bookkeeping. One entry line per mode; a form tying a field to a group of behaviors would remove it. (Control flow, Events)
• Generators. Whether ConeScript takes Cone's yields. (Control flow)
• The budget's unit. Steps or time; per block or per cascade of events; what a world sees when a block runs out. (Control flow)
• The spelling of dialogue (dialogue, line, choice(..., then:) are an illustration) and which act presents a dialogue to a visitor. (Text)
• The boundary of presentation. May the content say "four buttons", or only "a choice of four"; and when a guard offers an action, does the browser draw the choices its own way or the world its own layout, and which wins. (Text, Visitors, Overlays)
• Formatting. Numbers, moments and quantities into text; placeholders. (Text)
• Text keyframes. An animator whose values are lines of speech. (Text, Animators)

Part 2. Parts and the world tree

• Places as names. A villager's round names places that are not parts; is a named place a part with no shape, or something else. (Parts)
• Persistence. Which server state survives a restart (the zone a visitor was in, their bags) and which resets (a lantern's glow). (Parts, Fields, Distribution)
• Whether mutable should be inferred from whether anything writes the field. (Fields)
• A field shown only to its own visitor. A quest log: a fourth place beside client, server and both, a server field told by private reply, or both. (Fields)
• Relevance to each view. "Only for faces within 40 m of the eye" is neither client, server nor both; a behavior that matters only near the viewer. (Fields, Subscriptions, Package behaviors, Distribution)
• A design holding its own copies. If like copies everything but the frame, a design's copies among its children are copied too; skip them, or keep copies in a separate holder. (Designs)
• A copy cannot take anything away. Whether a copy may ever remove what its design holds. (Designs)
• Names of spawned copies. A second fall below half health would spawn twenty more trolls under the same names; does spawn number its copies itself. (Designs)
• Which differences are "the same" for sharing. The engine must know which fields a shape reads, so construction must be checked against the fields it names. (Designs)
• Who may change a design while the world runs. The point of a common field; a rebuild of every copy for a construction field. (Designs)
• Naming every copy from elsewhere. How a rule outside a design says "every copy of X". A proposal answers this: copiesOf(design) and holder.parts (Designs: finding every copy).
• Frames round the viewer. The spelling of frame kinds (at: around(camera, ...), around: eye; by direction is the direction: argument); things round each viewer's eye as parts with a camera frame, outside client, server and both. (Frames, Sky and weather, Distribution)
• Generated-list entries and bones as kinds of frame. (Frames)
• Two writers of one place. An animator on a being's or a body's place while physics also writes it. For a body a proposal answers it: the animator takes the body out of physics until it ends (Physics: bodies); a being's place stays open. (Animators)
• A view of blocked rain from the sky, a proposal: blockedByRoofs: true on falling, to be built; today rain falls through roofs. (Frames)
• Ground everywhere, and edges. Whether there is ground everywhere is the designer's choice; a bounded land states its edge as the option edge:, and only sea(wade:) is built; the rest of the vocabulary of edges (wall, wrap, fall) is open. (Frames, Terrain)
• Weather placed in the world (to be built). A storm as a placed part moving with the wind, the near drops asking the storms with rainAt how hard it rains at each point; today the rain is the weather's, the same everywhere. (Frames)
• The cache's key. The description's own hash plus the vocabulary's version; which vocabulary changes invalidate which products. (Loading, Construction)
• Start before everything is built. Whether a start act may read built products before all of a large world has arrived. (Loading)
• Products not yet named. Solids, picking triangles, the navigation mesh: the content does not say which consumer needs which, so the engine cannot decide per machine. (Loading, Construction)
• A start act that depends on time since load would make warm and cold starts differ. (Loading)
• Nothing signals creation today: created is not yet provided by the browser. (Loading)
• A loop of dependencies: read, then write. A feature's level reads the land's height, and the land is carved by the feature; broken only by build order; a stage, or a rule for which land a feature reads. Terrain built in stages that read what came before is a design question. (Loading, Subscriptions, Terrain)
• Scenes and regions: spelling. How a part is declared a scene or a region; whether a region needs a word at all. (Worlds, scenes and regions)
• A scene's own clock and sky. Whether each scene has its own day, sun and weather, or shares the world's; the pages speak of "scene time" for the world's one clock. (Worlds, scenes and regions, Sky and weather)
• "Region", one word with several meanings: a partition of a scene, a region of a shape, a named region of a product, and on older pages the labyrinth as a place with its own settings. (Worlds, scenes and regions, Fitted and grown, Sky and weather, Cameras)
• Logic that reaches into a sleeping region or another scene: runs only on the server, is refused, or goes through world state shared at the top. (Worlds, scenes and regions)
• A sleeping region's summary: what it is, how a region states it, and what state a region wakes in for a visitor arriving late; its cost on a shared server. (Worlds, scenes and regions, Distribution)
• Is waking a creation? Whether a region's parts' on(created, ...) runs when it wakes or a visitor enters a scene, once per machine, or only when the world first makes them. (Loading)
• What a visitor carries: between scenes, as world state keyed by being; between worlds, as the person's, outside the content. (Worlds, scenes and regions, Outside the content)
• Portals: spelling and naming: a portal as a thing a part is, its mouth, its arrival by path; how another world is named, and what a portal shows when that world cannot be reached. (Portals)
• Two-way portals: two declarations, or one making both mouths; one way stated or by absence. (Portals, Physics)
• Who and what may pass: how the rule is written, what a refused visitor meets, what happens to what stays behind, how a destination states what it accepts and a giver marks a thing as carryable. (Portals)
• A window into another world: drawing a stranger's world live inside this one means loading it; whether that is allowed, and within what limits. (Portals)
• Readiness details: how likely a portal is to be used, whether a window implies readiness, and two visitors arriving at one arrival at once. (Portals)
• Gates without portals: whether every gate (the corridor that will not end) becomes a portal within one scene. (Portals)

Part 3. Behavior

• What an area senses: areas across regions; who left. A proposal answers what an area senses and who left (Physics: areas, one mechanism); areas across regions remain open. held over several beings is closed: it is per being, inside each v in visitors. (Events, Physics, Worlds)
• Time since a value changed ("at least 1.1 s in this mode") cannot be said with held alone. (Events)
• A collision trigger, and which collisions are messages. A proposal answers the first: struck and cameToRest (Physics: a body's events); contacts between bodies already awake stay open. (Events, Physics)
• Where a handler runs: closed. A rule inside a part with lives: client runs on each visitor's machine, and only there. (Events, Sounds, Distribution)
• Message delivery. Bubbling to the parent, timing and order, replies, and who sees a message. (Events)
• One-shot sounds. An action play(sound, at:, heardTo:), a self-removing part, or both. (Actions, Sounds)
• Requests to engines. A general request such as a contact test, as a kind of action; throw, sleep and wake are proposed as actions of their own (Actions: throw, sleep and wake). (Actions, Physics)
• A lifetime on spawn (lasts: sim(3 s)), for parts and spawned effects. (Actions, Effects)
• A timed step. Whether a plainer form than keys(..., steps(1)) is wanted. (Actions)
• May world logic make a person's being perform an action? Recommended no. (Actions, Visitors)
• Telling an actor about a refusal: silent, as today, or a refused(reason) the browser presents. (Actions, Visitors)
• Live effect numbers. May an effect's numbers change once it has started. (Actions, Effects)
• Doing something to each of a set found at run time: the props' reset glides every moved prop home. A proposal answers this: each p in copiesOf(ninepin), one transition started per prop (Physics: bowling on the lawn).
• "Newest takes over" against "ignore a second press". A default overridden by a guard in the handler, or an alternative stated on the animator. (Animators)
• Animators before or after physics, or per animator. (Animators)
• The first library: the six kinds only, or named presets (an entrance, an emphasis, an exit). (Animators)
• Easing. steps(n) is in the syntax and is to be built in tweenstack. (smoothstep is now among the easings, proposal: Animators: easing.) (Animators)
• hold after the end: the syntax allows "nothing"; the package always leaves the end value. (Animators)
• Names and handles: an animator named with let, or its handle kept in a field. (Animators)
• A seventh kind, trail, for Ariadne's thread, stateful like a chase. (Animators)
• Behaviors as animators. Minds, the gait and the face rig fit "one motion per value" only if a being's actions, pose and face count as values; what happens to a replaced mind's state. (Animators, Package behaviors)
• A library's events. A library's contract must list the events it raises (footsteps). (Package behaviors, Sounds)
• An unknown name. What a browser does with a vocabulary name, or a library's kind name (patrol, graze), it does not know; the minimum browser level answers it for the core vocabulary only. (Package behaviors, Packages)
• Agreement between products. The walkable map's agent and the body's capsule must agree; nothing says they are the same fact. (Package behaviors)
• Locomotion and gravity as choices. The capsule, gravity and step height are built in; a world with no ground, or gravity per surface, must name its locomotion and each body's down. (Package behaviors, Physics)
• A shared flock needs exact stepping on every machine or the birds sent; where a value lives does not say what it costs per kind of behavior. (Package behaviors)
• State stepped each tick: answered (working hypothesis, 20 Oct) by stepAnimator, an animator the world writes as a step function (Animators: your own); bending the birds' wings to their beat joins posing a being from code (Package behaviors).
• Who declares actions: the world, with the browser choosing an input; the world with a suggested input; or a fixed vocabulary worlds only adopt; and an action a browser has no input for. (Visitors)
• One key for two actions whose availability never overlaps (sit and stand). (Visitors)
• How far a world may narrow targeting. (Visitors)
• Multiplayer configuration and world-defined input (group size, raids, key and gesture mappings): deferred. (Visitors, Distribution, Outside the content)
• The bodies a world supports: by skeleton, by package, by sizes; what "fits" means for a body that is not a person. (Avatars)
• What content may read of a visitor's avatar. The looking-glass copies the opener's person into a puppet; under the avatar proposal the world was given that description only to present. (Avatars, The looking-glass)
• A person's policy against a world's statement: how they meet before entry, and what the browser shows when they conflict. (Avatars)
• Gear granted to carry: how a world marks a gift as the visitor's to keep, and where a kept gift lives once the visitor has left. (Avatars, Outside the content)

Part 4. Construction

• Where a mapping's scale lives: a tile's size is written in the shape's projection and again in the material's bake, as a tiling painted image's is. (Textures)
• Pattern vocabulary: which pattern records and presets are vocabulary names, and how a world's own texel function is admitted beside them. (Textures)
• A pipe operator? When the tools are plain functions rather than methods, a chain cannot be written and nesting reads inside-out; a pipe (as F#'s |>) would read left to right. It is a convenience, left out until it earns its place. (Construction)
• Lengthening one zone (a column taller without a larger capital). (Construction)
• Cost as a requirement. "Detail down to about 3 mm" rather than 1024 texels; whether content may state a live image's resolution or only a quality. (Open functions, Images, Cameras)
• Method or shape. When two tools make the same shape (a swept horn, a distance-field horn), does content name the tool or describe the shape; likewise per-point gullies against an erosion package. (Construction, Sculpting, Terrain)
• How a sculpted surface travels: strokes, a baked displacement over a procedural base, or not as content at all. (Sculpting)
• A recipe's version. A recipe's meaning depends on its tool's version: the same fields make a different person when the package changes, which matters most for an avatar carried between worlds. (Sculpting, Fitted and grown, Avatars)
• One kind of randomness, and seeds. Sequential streams or hashes per place; randomness from the world's seed plus a name, so editing one rule or function never moves another's noise; seeds for placed individuals. (Generators, Open functions, Fitted and grown)
• Ordered rules as a relation: "keep clear of earlier" needs rooms and an order; the model has pipelines, not populations whose steps depend on each other. (Generators)
• Facts asked twice: a part's room is now its clearance:; the crown's reach is a fact the products should answer. (Open functions)
• A population's parent: a group part, the part it stands in, or the content's choice. (Generators)
• Requirements and caps mixed: a cap is a requirement; whether a world may also state a cap that is only a resource limit. (Generators)
• Stable numbers for a layout's parts: parts numbered by list position change number when a rule is edited. (Generators)
• A function as a parameter: what a tool's contract for a function parameter says. (Open functions)
• Whole-field questions and neighbors. "The highest point of the raw hill" needs every point first (a lattice, highest(f, every: d)); a slope should be the field's answer, not a difference of samples. (Open functions)
• Exactness per product. Bit-identical (the land) or only close (a fresco, a texture, an effect); content has client, server and both for fields and nothing for products. (Open functions, Textures, Effects, Terrain)
• Regions, landmarks and bones of a product. How content names them, which products offer which, whose bone names, and whether a bone is a part, a named frame inside a product, or only a relation. (Fitted and grown)
• Rigid and skinned: two words, or one, and a word for following a surface's morphs. (Fitted and grown)
• Layer order of clothes, and covering (a helmet over hair). (Fitted and grown)
• Parts that exist because of a field (the outfit). (Fitted and grown)
• Identity against presentation: which of a person's fields a world may change, which decides whether a world can dress a visitor's avatar. A proposal answers this in part (Avatars). (Fitted and grown, Avatars)
• Distant forms: how a distant form is written, how a designer marks what must survive, how many forms a part may have, which live values one may carry, and whether a hand-made form is allowed beside a built one. (Construction)
• A field that reads a part: the pad depends on the cottage's place, and the cottage stands on the land; a root field both read (cottageSpot) answers this case, the general question stays open. (Terrain)
• Changing the land while running (digging, flooding). (Terrain)
• Questions the land's type does not list: a land's own questions beyond height, gradient, normal, curvature, the distances to its features and a flat area's contains, such as how thick the forest grows. (Terrain)
• A ground look from where you are: color chosen from height, facing, masks, the distance to the eye, the size of a pixel on the ground and the time, not from texture coordinates. A design question. (Terrain, Materials)
• Features in packages: spline-carved paths, rivers and roads are not in terraingen. (Terrain)

Part 5. Appearance

• Renderer concerns in content. Shadow casting, light layers, shadow-only parts: declarations, never, or requirements ("the frame is lit from within") the engine meets. A proposal writes layers and shadow switches as declarations (Lights: light layers, shadows); shadow-only parts, and requirements in their place, remain open. (Materials, Lights)
• Physical or perceived color, for surfaces and for lights. (Materials, Lights)
• Emission on the material or the part; and a light as a part of its own, an aspect of the glowing part, or derived from a glowing material. (Materials, Lights)
• One glass or two: the lanterns' see-through amber and the windows' refracting glass. (Materials)
• One material a part, or several over regions of a shape. (Materials)
• Which model of gloss. (Materials)
• Override beyond tint. (Materials)
• Local or world-wide materials, and how their names resolve. (Materials)
• Who may write a formula for a material that reaches several objects. (Materials)
• Changing a definition while running (autumn leaves). (Materials)
• Arrival order of definitions. (Materials)
• May a world carry an image, or recorded sound? Never; yes, as data, for what no recipe makes; within a size; in which formats. (Textures, Sounds)
• Weathering: whether wetness and seasons change a texture's inputs while the world runs. (Textures)
• A light bound to an effect (a brazier's light following its flame), and a heat haze. (Lights, Effects)
• Several suns: the model allows them; the renderer has one directional light. (Lights)
• Value types with presets: how a record like the weather state and its named values are declared. (Sky and weather)
• One fact, two statements: dawn and dusk follow from date and latitude; which settings are derived. A proposal answers it for dusk and dawn, which the sky gives (Sky and weather: dusk and dawn); other derived settings remain open. (Sky and weather)
• Where a change of weather comes from: a schedule, a draw per run, a handler. (Sky and weather)
• Blocking and shelter. Rain and wind blocked by shape as a shadow (blockedByRoofs, to be built; today rain falls through roofs), plus designer-marked areas, stated once and read by every engine; speech heard through walls today. (Sky and weather, Sounds, Overlays)
• A wind field: fixed today, a field; whether it may change, and whether the ground effects' own pushes and the sound's strength should follow its speeds, which the clouds alone read. (Sky and weather)
• Who may change the clock's rate in a shared world. (Sky and weather)
• Settings by region: a region's overrides stated once and read by every engine; which region's settings a picture of another place uses. Under the hypothesis of scenes, settings belong to a scene and a picture uses the scene it shows (Worlds); a zone's settings as an area is a proposal (Physics). (Sky and weather, Cameras)
• Effects as code or data; fire as a word the browser realizes as particles or a glowing shape. (Effects)
• Sounds: parts, or the view's bindings, or the browser's own; a voice as a property of the person. (Sounds)

Part 6. The 2D half

• Per camera or per visitor. A mirror's picture is made per camera, a speech plate per visitor, rain per camera; the language needs a way to say which. (Images, Overlays, Cameras)
• Which channels an image carries beyond color, transparency and depth (normals, part ids for the pointer). (Images)
• Depth in overlays: one depth for a whole image or one per pixel. (Images)
• Text and layout at a closure: caret, selection and wrapped-label heights from the text package. (Layouts)
• One renderer for 2-D: vector2d as uilayout's renderer. (Layouts)
• Fonts: which a world may name, and the license of any it embeds. (Layouts)
• Accessibility: names and roles for screen readers, from the start or later. (Layouts, Overlays)
• Two inventories: uilayout's and worldinteract's. (Layouts)
• Where overlays sit in the pointer's order. (Overlays)

Part 7. What the engines take

• A form for what a part is: vocabulary functions naming the part (body(self, ...), seat(frame, ...)), or modifiers on the part's line, as areas and platforms now are. (Physics)
• Solid or not by default, and whether content names its solid at all. (Physics)
• Two areas on one part: one area a part, named by the part, or more, each named. (Physics)
• "At rest": the engine's notion or the world's. A proposal answers it: both, the engine's as cameToRest, the world's written from p.speed and p.spin (Physics: bowling on the lawn).
• Determinism: predicted props need the same physics bit for bit on every machine. (Physics)
• A portal as one thing: a pane and a gate that must agree, written as two; one way stated or by absence. A proposal answers this (Portals). (Physics, Cameras)
• Zones with settings as areas: sheltered, underwater (swimming), a sound zone, read by every engine. (Physics)
• Seat rules: reach, reservation, a bench for two. (Physics)
• A part's kind changed by state: mirror to window as a field of one type or a change of type. (Cameras)
• A turned or scaled window. How the picture through a portal that turns or scales is drawn. (Cameras)
• Waking by eye: whether a portal's window or a far-seeing stone counts as an eye that wakes the region it shows. (Cameras, Worlds)
• Cameras a world controls, and how they meet possession. (Cameras)

Part 8. The browser and the network

• Versions with extensions. Extensions join at browser releases, or a world names an extension and its minimum version. (Packages)
• Extensions' permissions: which may be declared, who approves them, and what a world using a revoked extension shows. (Packages)
• Where rules run: server, client, or the same rule on both, the server deciding and the client predicting; separate sections of a world, or each rule labeled. (Distribution)
• Where a person's avatar description is kept, and who may fetch it. (Outside the content)

Found by the worked examples

Writing the examples whole, in the reference pages' spellings, found these; each example's last section has the detail, and where a reference page now carries the question, its Open questions section is linked first.

• An enum case used as a number in a generated name (lantern[2 * p + side]). (Values, The lanterns)
• Inline enums against declared enums. A proposal answers this: enums are declared (enum sexKind { male, female }), as in Cone (Introduction: minimal forms first). (Values, A villager)
• each as a layout function and as a statement. A proposal answers this: the function is map(list, x => element), and each is only the loop (Layouts). (Control flow, Layouts, A boss and its army)
• Deep relative names. A bare name is found in the current part and outward (Parts), never below it, so a grandchild (envelope.basket.cap) must be written in full; whether short names for nested parts (a guard under its plinth) are wanted. (Parts, The balloon, The riddle)
• A turn and a scale in a frame are proposed as the part options rotation: and scale: (Parts: part options); whether a scale may differ by axis, and whether a turn may be a facing. (Frames, The balloon)
• The ride and riding as two sources of truth. (The balloon)
• The walking, jumping, landing and ragdoll numbers are the engine's; whether a world may change them. (Physics)
• Which body a visitor arrives in: answered (working hypothesis, 20 Oct): the world's avatar, with the person's profile (dimensions, look, key mapping) applied within the world's ranges; bringing one's own avatar is a later option a world may grant. (Avatars)
• A design as a parameter's type (fn honest(g: guard)). (The riddle)
• What every speaker must have: a world rule over all speech reads fields (title, voice, height) no contract guarantees. (Visitors, The riddle)
• Joining text in a value. Whether <- may join text inside a value expression (a layout's words) as well as into a mutable local. (The riddle)
• Option handles: ended on an optional handle has no spelling. (The riddle, The looking-glass)
• Negating a field: whether a prefix minus binds looser than the dot, so that -cottage.link means -(cottage.link). (The looking-glass)
• A part's look against its material (pane.look derived, no material:). (The looking-glass)
• Behaviors of a being's actions beyond npcbehave.arrive(..., delay:, turnRate:) have no reference page; the looking-glass's reflection uses arrive, and its handle ends like an animator's (Behaviors, The looking-glass)
• Copying what the content does not own (a visitor's person). (The looking-glass)
• A look built from the land's methods (a ground look from where you are is a design question); distances "up to" a reach. (The island's land)
• What value a behavior writes: the walk "writes the pose" and the pose is also derived; a behavior's contract should name the values it writes. (Package behaviors, A villager)
• Rules on every being, a visitor's included (the hail). (A villager)
• A copy whose design is a field's value (part body: who), and a behavior partly applied. (A villager)
• Seeds from a loop index; a trigger that fires once in a part's life; you outside a layout; where the visitor's composite is declared. (A boss and its army)
• Performing a carried act (perform(...)), presenting a dialogue (present(...)), spreading a list into a list (now Cone's List[T]() <- a, each xs), a dialogue's fields, a unit a world declares (coins). (Text, A shopkeeper's dialogue)

← A shopkeeper's dialogue | Contents