Skip to main content

Pages

A Page is a major destination in a Parable: a place where people read, explore, or finish a piece of work. Pages give a Parable its routes and navigation. A Page holds no data and no queries of its own. It arranges Panes, and the Panes own the values, logic, and styling. This split keeps destinations easy to rearrange, because moving a Pane between Pages never touches the data it shows. Parables are product experiences, so a Page must open fast: the data a reader sees first comes from stored Pipeline outputs, not from joins computed while they wait. Every Parable has a Home Page. Other Pages can sit beneath a Page to form a clear hierarchy. A Page has a small amount of layout code, a Perception that lists the Panes it renders, its own Policies, and a Palette. The Perception and Policies are part of the Page and versioned with it; the Palette is created with the Page and deleted with it. Its editor tabs are Programming, which shows its code beside its Perception, then Palette, Policies, Preferences, Plots, Panes, and Performance. A Page is composition only: its type is null, and its code may import only the Panes it declares and the runtime layout modules. Anything else, such as a chart, a control library or a company’s logo (BrandLogo), is refused at save with the import named; put that content in a Pane. In a Page’s code, a save refuses only its imports. Anything else the code holds, such as words, a control or a drawing, gets the note page-holds-content in its Warnings & Errors, which never blocks, so keep it out of a Page yourself. Each Page keeps a permanent identity, so links and references survive a rename. Editing a Page follows the Parable’s Collaboration Mode: in Personal, a save changes the Parable directly, and in Published Versions, it goes into a Patch that is proposed and published. Who may edit is decided by the Parable’s participants and the Page’s Policies. Publishing compiles every Page; a syntax error or an unavailable import stops publication and leaves the published Release untouched. A Page that declares no Pane, or declares a Pane that does not exist, is reported as a finding when its Patch is published. Never delete and recreate a broken Page to clear an error: that creates a new identity and breaks links to the old one.
  1. Name the destination by the job a person completes there. Ask Ponder to state who arrives, what they must understand first, and where they go next. Save that job as the Page’s description, in one sentence: every Page needs one, and a save without it is refused. Keep Home useful. Add a child Page only when the content deserves its own route and title. Inside the current Page, a part is a Pane when it passes the test in the Panes Power, and a Package groups related Panes. Every Page except Home has a parent Page. When a new Page has no parentPageKey, the server puts it under Home, after Home’s other child Pages, and replaces its order. To put it under another Page, send that Page as its parentPageKey.
  2. Declare the Panes. Ponder adds each Pane the Page renders to its Perception, creating a Pane first when the Parable has none for that content. Values, configuration, controls, and queries belong in the Panes that own their meaning, never in page-local substitutes. Work down from what the Page shows first: any expensive query behind it should be a Pipeline its Panes read (see the Pipelines Power).
  3. Compose the layout. Ponder writes short layout code that places the declared Panes with ordinary elements and CSS. The Page imports its declared Panes from its own module, @parable/<Parable handle>/<Page handle>, and renders each by the name its Perception gives it: import { panes } from "@parable/acmeWeekly/home"; export default function Home() { const Logo = panes.logo; return <div className="parable-page"><Logo /></div>; }, where the Perception says readonly panes: { readonly logo: Panes["brandLogo"] } (with import type { Panes } from "parable/panes"). A Page imports nothing else except react and motion. A Page reads no Plot: each Plot belongs to the Pane that owns it, and that Pane renders the rows. Never call panes.<pane>.plots.<plot>() or panes.<pane>.plotSource() in a Page’s code, and never map Plot rows there. Render the rows in the Pane that owns the Plot and place that Pane on the Page. When several data Panes together make one thing that passes the test in the Panes Power, put them in a layout Pane, whose type is null. Each data Pane still renders its own rows. Page code that reads a Plot gets the note page-plot-read in its Warnings & Errors. The layout adds no extraneous copy: no sentence that explains a Pane, says where a value came from, tells the reader they can change something, or repeats what a Pane already shows (see the Panes Power). Walk the reader’s path first, then the contributor, administrator, and support paths. Configuration and permission-recovery controls need a deliberate home in a Pane too, and a disabled one says why (see the Panes Power).
  4. Preview the route. Check navigation, loading, empty, and error states, keyboard use, both themes, and the XS to XL preview sizes. A Page with no Panes shows an add-a-Pane placeholder and can still be saved. Design a Platform Parable narrow-first: its tab opens it above the conversation in Ponder’s narrow column, the default layout, or over the Parable for a person who keeps plugins inside the Parable, so make each of its Pages work at S (390 px wide) first, then check the wider sizes. A preview draws no live data, so a Pane that reads a Plot shows only a placeholder in it: check that Pane with Check a Pane (step 6) instead. When you have no tool that previews a Pane, you cannot do these checks: run Check a Pane (step 6), name the Panes you changed, and ask the person to look at the Page.
  5. Design for every Provider. Every Parable is designed for full Provider coverage, however rare the Provider, and for any Workspace, whichever streams it turned on, with a useful state when none is connected, a useful state when some are, an empty state in every Pane, and a reason to connect more. On a Page with several visuals, each visual’s Pane wears ImproveParable on hover; otherwise one Improve this Parable band goes at the top of the Page’s first Pane that always draws. The band shows only while a Provider is missing, so never give it a Pane of its own: that Pane would draw nothing once every Provider is connected. The Home Page’s Perception declares the Parable’s Provider groups, and its content shows Populate this Parable while a Required to Populate group has fewer connected than its rule asks or no Provider has data yet (see the Populate, Perceptions and Panes Powers).
  6. Repair in place. When a Page fails to render, read the visible preview error and fix the Page or the Pane it declares within the same Patch. A build ends only when Check a Pane is clean. After each build save, call Check a Pane for the Panes you built or changed. It reports, for each Pane, whether a Page shows it, whether it draws without an input, what panes/resolve gives it, the rows of its Plots, and its Warnings & Errors. Fix each problem it reports in the same Patch, then check again. Answer only when clean is true. A Page opens with no input from the reader, so every Pane input gets a default that draws, such as the last 12 weeks or all teams. A Pane that waits for a value shows only “Choose a Preference or provide an input.”, and the check counts it as a problem. When a check is pending, check again. A note does not block, but read it: a Plot with no rows needs an empty state. The check reads a Plot that takes inputs with null for each input. A Plot whose input does not take null is not read, and that is a note, not a problem: the Pane sends its own values. Keep a problem only when its own sentence says to keep it, and say so in your answer. Never keep a Pane that opens empty. A Pane that the person asked to take an input still gets a default that draws, such as the last 12 weeks or all teams.
  7. Give the Parable its description and its preview. They show on its sidebar card, with its name and mark. A Parable in Published Versions publishes only when it has a description. It does not need a preview to publish. A Parable that is not Personal gets a card picture by itself. At its first Propose, or at a Publish while it has no picture, Ponder Details makes an image set at Speedy: a scene and a story, with logos off. The scene goes on the card. A person’s favorite image in Ponder Details replaces it at once. A favorite does not wait for Publish. A Personal Parable does not need a description or a preview. Make them when you build a Parable or change what it shows. Also write the description when Prepare or a publish asks for it. In Ponder, make them at Ponder Strong. If this turn runs at another level, start a Run at Ponder Strong in this Problem to do this step. If you cannot start one, ask the person to choose Ponder Strong and ask again. An agent outside Ponder has no level, so this rule does not apply to it.
    1. Read the Parable. Read its name, its current description, and its Pages, Packages, Panes and Plots with their descriptions. Read the Provider groups that its Home Page declares, and the outcome of this Problem. For a Lab, read its pages and its main components.
    2. Write the Parable’s one idea in one sentence: what a reader learns or does with it. List the three or four things that it shows. Use only what its Pieces show.
    3. Write the description. Keep the current description if it follows these rules. If it does not, write a new one.
      • Write one sentence of 25 words or fewer, in plain words that a new teammate understands.
      • Say what the reader sees or does. Do not start with “This Parable”, with “A dashboard”, or with a verb such as “Shows”.
      • Name kinds of data, such as calendar, mail, team chat or HR system. Never name a vendor, a product, a customer, a person, a model or a tool.
      • Do not write counts, dates or other values that change. Do not write plans. Do not claim what the Parable does not show.
      • If the Parable shows a fictional company’s data, start with the name of the Parable whose idea it shows, then the words “with a fictional company’s data:”.
      • Two good examples: “Where your teams’ working hours go, by category of work.” and “The four DORA keys and the throughput behind them.”
    4. Make the screenshot preview. Use the tool “Make a Parable’s preview”. It draws the first screen of one Page on a sample company’s data, in light and dark, and stores the two images. It never uses this Workspace’s data. If the Parable has a screenshot and its one idea did not change, keep that screenshot.
      • If you do not have this tool, the Parable has no screenshot for now. Do sub-step 6 and tell the person. The tool needs a browser. Ponder has it only in a chat turn where a browser runs. An agent outside Ponder does not have it.
      • Choose the Page. Use Home, unless another Page shows the one idea better.
      • The picture is the whole first screen of the Page, about 960 by 600 pixels, with no crop. The card shows it about 450 pixels wide, so small text is not legible there. That is correct: the picture shows the shape of the Page, its main numbers and its charts.
      • The tool says which Release it drew. If that Release is older than the Patch in this Problem, tell the person that the preview shows the last deployed Release.
      • If the tool says that the sample company has no line or no Refresh of this Parable, the Parable has no screenshot for now. Do sub-step 6 and tell the person.
    5. Look at both pictures.
      • The tool names each Plot that returned no rows. If its Pane shows a large empty state, choose another Page.
      • Each Pane in the picture must show data or a useful state. A Pane that shows an error is a failure.
      • The picture must show only the sample company’s fictional names and values. If it shows a real person’s name, a real email address or a customer’s name, stop and tell the person.
      • If a check fails, choose another Page and make the preview again. If the tool refuses a Page, it says why.
    6. Draw the illustration preview too. Each Workspace shows either the screenshot or the illustration on its cards, so a Parable needs both. If the Parable has an illustration and its one idea did not change, keep that illustration. The illustration is a quiet, exact drawing of the Parable’s one idea: ground and fine lines, a field of identical marks, and color only where the Parable draws a distinction. A person who knows the subject must recognize this Parable in one look. A generic chart that could belong to any Parable fails.
      1. Find the one idea. Write one sentence that says what a reader learns or decides with the Parable, and name the two or three distinctions it is built on. Use its description and its Pages. For example: “Who outside the company the team reaches, and who writes back.” Its distinctions: inside or outside the company, answered or not, met or not.
      2. Find a form that shows the idea and its distinctions, and nothing else. These constructions work:
        • A field of identical marks, such as dots, squares or tiles, one for each person, contact or outcome, where a change of state carries the meaning.
        • Lanes, branches and merges, as in a git graph.
        • Threads or arcs between two sides of a line, such as the team and the outside world.
        • Flat or isometric planes, trays and stacks. Draw isometric at 30 degrees, never in perspective.
        • Dotted zoom lines that open one part of a form into its detail. Never draw a screen, a window, a table, a menu, a cursor, a chart with axes and values, or a copy of a Page. Never draw glow orbs, halos, light blobs or flares. Never draw clip-art such as a sun, moon, rocket, trophy, person figure or clock. Never draw a meter, dial, gauge or progress bar.
      3. Give each color one meaning, and keep most of the picture ground and fine lines.
        • Ink lines and outlines are the things the Parable counts.
        • Plum is the state or result the Parable is about, such as shipped work, an answered thread or an outcome. A faint plum may mark a state between the two.
        • Pink is the one exception or highlight, such as the work waiting for review, the meeting held or the suggested demo. Put pink on three marks or fewer.
        • Use no other color.
      4. Lay out the picture.
        • The canvas is 1280 by 608 pixels. The card shows it about 480 pixels wide, so each size shows at three eighths.
        • Keep every form at least 64 pixels from each edge, and leave a lot of empty ground. Center the form.
        • Make each line that carries meaning 2 to 3 pixels wide and each mark that carries meaning 10 pixels or more. Construction hairlines are 1.5 to 2 pixels and say nothing.
        • Draw circles for points such as people, contacts and commits. Draw squares and rectangles for units, with corner radii of 2 to 4 pixels. This rounding is for illustration marks only. Product controls keep the design system’s square corners. End lines round.
        • Draw no shadows and no gradients.
      5. Draw it from this start file. Keep the palettes, the dot grid and the classes.
        • Draw a point that is counted but has not reached the state as a circle with class out, and one that has as a circle with class plum. Put a highlight inside a circle of class ring-pink, 6 to 8 pixels larger.
        • Draw a curved thread from x0, y0 to x1, y1 with M x0 y0 C m y0 m y1 x1 y1, where m is halfway between x0 and x1.
        • Place an isometric point at x, y and height z as 640 + (x - y) * 0.866 across and 304 + (x + y) * 0.5 - z down. Draw the visible faces of a block as polygons, back blocks first.
        • Write no words, numbers, letters or logos.
        • Use only the elements svg, g, defs, style, title, desc, pattern, clipPath, mask, rect, circle, ellipse, line, polyline, polygon and path. Refer to nothing outside the file. Keep the file under 32 KB.
      6. Check the illustration before you save it.
        • One idea: a person who knows the subject can say which Parable this is from the picture alone.
        • Quiet: most of the picture is ground and fine lines. Plum and pink each mean one thing, and pink is on three marks or fewer.
        • No interface and no decoration: no window, button, table, menu, cursor, text, glow, clip-art or gauge.
        • Card size: each line that carries meaning is 2 px or more, and each mark that carries meaning is 10 px or more.
        • Light and dark: each color comes from a variable that the three palette lines all set.
        • Honest: the picture shows only what the Parable shows. It shows no real value, name or logo.
        • Three examples. Work Activity: a working day is a hairline arc through the tools a person touches, each an outlined frame. Only the first and last tools are pink, and they drop to a thin pink span on a ticked baseline. Software Delivery: main is split into five weekly bays, and in each bay short branches fold into main, with the plum merge dots rising from two to five. Sales engagement: the team sends threads past a dashed domain line to contacts grouped by account. Answered threads are plum, and the contact the team met is ringed in pink.
    7. Save the description and each preview you made in one call to “Rename a Parable or change how it is labelled” (rename_parable). Send the two image ids that the preview tool gave as previewLightSha256 and previewDarkSha256, and send the illustration as previewSvg. A save of one kind of preview does not change the other. Send expectedRefVersion: refRevision from check_parable_state, or in Published Versions the sourceRefVersion of the Patch. In Published Versions, send the id of this Problem’s Patch as proposalId. The tools still call a Patch Changes. If this Problem has no Patch, open one first. If the server refuses a preview, the answer names the rule. Correct only that rule and save again.
A good Page has one clear job and a name that says it. A reader can reach it and leave it by keyboard and on a narrow screen, every declared Pane renders quickly on the Workspace’s full data, and missing or denied data shows a useful state instead of a blank area. Every time on it reads in the reader’s time zone and clock, such as “12:31pm ET”: a Page shows no time of its own, and its Panes format each one with formatTime and formatDateTime (see the Panes Power). Repair controls stay reachable while the preview shows an error. Check the result by saving, opening the Page at more than one preview size, and confirming its Patch reports no missing Pane reference. A Pane preview inside the conversation uses captured data and cannot run live SQL or save settings, so confirm data-dependent behavior in the running Parable. An attractive static arrangement is not a finished destination.

Formatted Pages

A Page has a format, chosen when it is created and fixed afterwards: product (the Pages above; Home is always one), prose, presentation, playbook, proceedings or probe. A probe also gets one participants Page, which Parable makes. The Page row’s format field holds the format. Never delete and recreate a Page to change its format. A formatted Page keeps everything a Page has and adds authored words. Its words are an implementation row on the same Page, language page_content: JSON with format (the Page’s own), version and the fields of that format. Its images are a second row, language page_assets. Its code is the tsx row. A Page has at most one row per language. To change one, send that row again with its existing entityKey, programKey (the Page’s entityKey), language and the whole new code. Never add a second row. Formats are not an app builder. Each format is a fixed data model that the server checks, parts that Parable draws, and a limit on what you write. Never store data a format does not model, never add routes or tabs, and never hide or restyle a part Parable draws. Who writes the layout:
  • prose, playbook, proceedings and participants have a fixed layout that Parable ships. Their tsx row is one line, such as export { PlaybookPage as default } from 'parable/pages';, and the server refuses any other code for them. Write only their content, and leave their tsx row out of every save.
  • presentation and probe layouts are yours: a slide inside <Slide>, a Probe inside <ProbeForm>.
A Page may hold only some formats. A product Page holds product Pages and the root of every other format. A playbook holds playbooks, a prose Page holds prose Pages, and a proceedings Page holds proceedings Pages, to any depth. A probe holds product Pages (views of its results) and its one participants Page. A presentation that is a deck root holds its slides, and a slide holds nothing. A participants Page holds nothing. The package read lists, for each Page, the formats it may hold (pageChildFormats). The server refuses any other placement and names the rule. A new formatted Page starts with its format’s empty content, and its layout draws an empty state with Ask Ponder. There is no starting content to pick from. The one exception is a probe: it starts as the Example Probe (see Probes). Write every formatted Page’s words from what the person asks for. Save with the ordinary Piece edit for the Parable’s Collaboration Mode, and raise version by one on each change. Say which parts changed. Do not claim a Page looks right unless you saw it; the person sees it on the canvas at once. A region is {"name": "title", "doc": {...}}, and doc is ProseMirror JSON. The top node is {"type": "doc", "content": [...]}. Blocks are paragraph, heading (attrs.level 1 to 3), bullet_list and ordered_list holding list_item nodes that hold paragraphs, task_list holding task_item (attrs.checked), blockquote, callout (attrs.tone tip, alert or note), table (table_row of table_header and table_cell, each holding paragraphs), code_block, horizontal_rule, image and pane. Text is {"type": "text", "text": "..."}, never empty, with optional marks: bold, italic, underline, strike, code, highlight, and link (attrs.href). An empty region is a doc that holds one empty paragraph. Region names match ^[a-z][a-zA-Z0-9_-]{0,63}$ and appear once. The server refuses content that breaks a rule and names what to change:
  • a link must be http, https or mailto;
  • an image node’s attrs.assetKey must name an image in the Page’s page_assets row. Never write image bytes or data URLs yourself;
  • a pane node (attrs.paneKey, the Pane’s entityKey; attrs.height or null) must be declared in the Page’s Perception first;
  • every key the content’s type requires must be present and not null, at every level. A step’s title is required: write "title": "" for a tip with no title, never leave the key out;
  • content is at most 512 KiB.
A layout you write follows these rules. Style with inline styles and one <style> block of selectors on data attributes, using theme tokens only, never hex colours, so the Page follows the viewer’s ivory or obsidian theme. Import only from ‘parable/pages’, ‘parable/panes/placeholders’ and the Panes the Perception declares. The Page runs sandboxed: no network and no forms. Draw an icon as a Font Awesome <i className="fa-sharp fa-solid fa-NAME" />, which the Parable draws into the sandbox for it. Keep the layout usable at phone width.

Presentations

A Presentation is a slide deck. The deck root is a presentation Page and is slide 1. Its child presentation Pages are the other slides, in order. A slide is 16:9 and scales to its frame. On the canvas every slide is read-only in every mode. People change a deck through you: when someone viewing a slide asks for a change, “this slide” is the Page they are viewing. Present shows the deck full screen. The presenter view shows each slide’s notes in a second window, and the audience never sees them. A slide’s layout is its tsx row, and you write it. A new slide’s tsx row draws eyebrow, title and body; its content starts with no regions. Every slide also has notes: the speaker notes, which the slide never draws. Regions that share a name keep their words when the layout changes. The requests you will get:
  1. Change words (“change the title”, “tighten the bullets”): rewrite those regions in the slide’s page_content row and keep every other region as it is.
  2. Add speaker notes: write the notes region as paragraphs of what the presenter says.
  3. Change the layout (“make this a two-column slide comparing X and Y”): write the new layout’s code into the slide’s tsx row and, in the same save, the content with the layout’s regions filled. Keep a region the new layout does not draw, so switching back restores it, unless its words moved into the new regions.
  4. Add a slide: create a presentation Page whose parentPageKey is the deck root, in the same save as its page_content row and its tsx row. Name the slide for its subject and give it a camelCase handle that no other Page, Package, Pane or Plot in the Parable uses: they share one handle namespace. Put it after the slide being viewed, and renumber the order of the slides after it, sending each moved slide’s full Page row.
  5. Write several slides at once: plan the deck first, then send one save for each slide. Each save holds that slide’s Page with its two rows.
Write slide words the way good slides read. A title is at most eight words. A bullet is one line. Put the detail in notes. A layout draws everything inside one <Slide> from ‘parable/pages’. Slide is the 16:9 frame: the surface, the safe area and the theme’s colours and fonts. surface=“inverse” is the dark surface for a section break or a closing slide, bleed drops the safe area, and style lays out the area inside it. Put an image or a Pane in <SlideMedia name="media" kind="image" /> (or kind=“pane”), which draws the empty frame when there is nothing to show. Give every size in container units (cqh, cqw): titles 7cqh, display titles 10cqh in var(—typography-font-family-serif), body 4.2cqh, captions 2.8cqh, and nothing below 2.6cqh. Text is left-aligned. Never draw notes, never scroll, and never change the slide’s size or aspect ratio. Use only images the slide’s page_assets row already holds; if a slide that draws an image has none yet, leave media as an empty doc. For a live Pane on a slide, declare the Pane in the slide’s Perception first, draw <SlideMedia name="media" kind="pane" />, and put one pane node in media.

Prose

A Prose Page is a document on a paper-width sheet, like Google Docs. It is the one format people type into on the canvas. It is one region, body, and its first block is the title: a paragraph with attrs.style “title”. A paragraph may carry attrs.style “subtitle” for the muted line under the title. Parable draws it: the sheet, the toolbar, the ”/” menu that inserts a block, and an outline of the title and headings with the word count. A Prose Page may hold Prose Pages, to any depth; use them for chapters or linked documents. The requests you will get:
  1. Write a document: write the body, its Title line first. A short document is one save. For a long document, plan the sections first, then send one save for each section. Each save sends the body so far.
  2. Change part of it: read the current body, change only those blocks, and send the whole body back with every other block as it was. People may be typing in the same Page, so never rewrite text you were not asked to change.
  3. Add a document: create a prose Page under the Page being viewed, with its page_content row only.
Put the point in the first paragraph. Use a heading (level 2 for sections, 3 below them) for each section, because the outline lists them. Use lists for things a reader will scan. Use a table only for data with rows and columns, and a callout only for the one thing a reader must not miss.

Playbooks

A Playbook is a step-by-step guide to a process, after the Ponder desktop app’s guides: a title, an overview and a byline, then numbered step cards, with headings, tips and alerts between them. Parable draws it. On the canvas it is read-only in every mode, and people change it through you. A Playbook may hold child Playbooks for sub-processes. Its content has the regions title (the task as an instruction: “Rotate a GitHub token”), overview (who it is for and what it gets done) and author (the author’s name), and playbook.steps, the blocks in order. Each block is {"key": a new UUID, "kind": "step" | "heading" | "tip" | "alert", "title", "action", "place", "owner", "minutes", "body": a rich-text doc, "shot"}:
  • step: one action, numbered. title is one imperative line that puts the element it names in bold: “Click Generate new token”, never “Click here”. action is click, right_click, double_click, type, key, navigate or manual. A navigate step has place {"app": "GitHub", "url": "https://github.com/settings/tokens"} and reads “Open GitHub”. owner (a role or a name) and minutes go only where the source says them.
  • heading: a section title between steps, about every 5 to 9 steps. It does not change the numbers.
  • tip: advice. alert: what cannot be undone. Both carry a short title and the words in body.
  • body: at most two short sentences, plus an image or a Pane.
  • shot: {"assetKey": an image in page_assets, "marker": {"x", "y"}, "crop": {"x", "y", "w", "h"}}, in parts of 10,000 of the image. The marker draws a ring where to click. Put a marker only on a real screenshot, and never invent one.
To change a Playbook, edit the steps array: keep the keys of the blocks you keep, and give new blocks new keys. Keep steps to about twelve and split a longer process into child Playbooks: create a playbook Page under this one with its page_content row, and replace the step with one that names the new Playbook.

Proceedings

A Proceedings Page is the write-up of one meeting, after the Ponder desktop app’s Proceedings: the title, when and where, an overview, key points, decisions, action items, the team’s own notes, and the transcript turn by turn, with the event and the people in a rail beside it. Parable draws it. A Proceedings Page may hold Proceedings Pages, such as the next meetings of a series. Its content has the regions title, overview (2 to 4 sentences) and notes (the team’s own words), and proceedings: {"startedAt", "durationMinutes", "source" ("Zoom", "In person"), "sourceDomain" (the domain of the tool in source, for its logo: "zoom.us"; null in person), "place" (a room or a city), "eventUrl" (the calendar event), "eventNotes", "attendees": [{"key", "name", "organizer", "response": accepted | tentative | declined | no_response}], "keyPoints": [...], "decisions": [...], "actionItems": [{"key", "text", "owner", "done"}], "speakers": [{"label", "name", "attendeeKey"}], "transcript": [{"speaker": a label, "startMs", "endMs", "text"}]}. Write only what the source says. Seven key points or fewer. A decision is only what people agreed. Every task that someone takes on is an action item, never a sentence in the overview or the notes: the Page draws each action item with a circle that people check off. An action item gets an owner only when the transcript or the event names one. Write done false; people check items off and edit them on the Page. Keep the transcript word for word and in time order, and never guess a speaker’s name: an unknown voice draws as “Speaker 1”. Never put a meeting link or a passcode in place or eventNotes. Read calendar events through Plots over the Provider Pools, never from the Provider again. A transcript is versioned content that every reader of the Parable can read, and earlier Releases keep it. Say so to the person before you write a transcript into a Page.

Probes

A Probe is a survey. It has a definition and a layout. The definition (probe in the page_content row) says what the Probe asks and how. The layout (the tsx row) says how it looks. Write the definition first, then the layout. People answer a Probe on the canvas. Each person’s response is theirs: it is stored for them, and only the Probe’s own binding writes it. Never save answers with preferences.save, Pane data or localStorage, and never copy answers into a Pane. A new Probe starts as the Example Probe, “Feedback on this Parable”, with example true. Parable draws an Example banner above it with Ask Ponder to change it. When the person asks you to change it, write their survey into the definition. The first change to the questions that the server accepts sets example to false, and the banner goes. An example cannot open and takes no invitations. The definition is {"example", "welcome": {"title", "body", "buttonText"}, "sections": [...], "rules": [...], "variables": [...], "hiddenFields": [...], "quotas": [...], "endings": [...], "sectionOrder": [...], "scoring": {"mode": none | quiz | score | outcome}, "presentation": {"layout": all | section | question, "progress": off | percent | count, "questionNumbers", "requiredMarks", "allowBack", "estimatedMinutes", "showResponseCount"}, "locales"}. A section is {"key", "title", "description", "items": [{"question": ...} or {"content": {"key", "kind": statement | image, "body", "media", "showIf"}}], "showIf", "shuffleItems", "buttonText"}. A question is {"key", "slug", "type", "title", "description", "required", "requiredMessage", "config", "validation": [...], "showIf", "prefillFrom", "variants": [...], "scoring", "identifying"}. Every key is a new UUID and is never reused. slug is the question’s column name in results: lowercase letters, digits and _, unique, never changed. config holds exactly the part its type uses:
  • short_text, paragraph: text {"format": any | email | url | phone, "minLength", "maxLength", "placeholder"}. maxLength defaults to 1,000 and 10,000.
  • multi_text: multiText {"preset": custom | name | address | contact, "fields": [{"key", "label", "format", "required"}]}.
  • number: number {"decimals", "min", "max", "unit"}. Numbers are fixed-point: 250 with decimals 2 is 2.50.
  • choice, dropdown: choice {"modality": single_select | multi_select | ranked_choice, "options": [{"key", "label", "image", "kind": normal | other | none | not_applicable, "pinned", "weight", "showIf"}], "shuffle", "minSelections", "maxSelections", "optionsFrom"}. Options with images draw as picture cards.
  • yes_no: yesNo {"yesLabel", "noLabel"}. consent: consent {"statement"}. Their answers use the fixed keys 00000000-0000-4000-8000-000000000001 (Yes) and 00000000-0000-4000-8000-000000000002 (No).
  • scale {"min": 0 or 1, "max": 2 to 11, "minLabel", "midLabel", "maxLabel"}, rating {"steps", "shape": star | heart | thumb, "allowNotApplicable"}, nps {"minLabel", "maxLabel"}, slider {"min", "max", "step", "decimals", "minLabel", "maxLabel", "start"}.
  • matrix {"rows", "columns", "cell": single | multi | dropdown | number | text, "choices", "shuffleRows"}, best_worst {"items", "itemsPerSet", "sets", "bestLabel", "worstLabel"}.
  • date {"min", "max", "includeTime"}, time {"mode": clock | duration, "minSeconds", "maxSeconds", "stepMinutes"}, signature {"label"}, click_map {"assetKey", "maxClicks", "regions"}.
  • file, payment, booking and media_answer are in the model, but the server refuses them until Parable has a store or a provider for them.
The model also holds parts the server refuses for now, each with a sentence that says so: shuffled sections and items, translations, hidden fields that read a Plot, A/B variants, answers filled from a hidden field, and recurring Probes. Do not write them. Logic: showIf and a rule’s when are condition groups {"match": all | any | none, "conditions": [{"operand": {"kind": answer | hidden | variable | locale, "key", "rowKey"}, "operator", "optionKeys", "number", "text"}], "groups": [...]}. A rule {"key", "on": start | answer | section_end | submit, "targetKey", "when", "actions": [{"kind": go_to_section | go_to_ending | submit | disqualify | set | add | subtract | multiply | divide | invalidate, "targetKey", "number", "operand", "message"}]} runs in order; the first rule that moves the person wins. A title may recall an earlier answer with {{answer:slug}}. Endings are {"key", "kind": thank_you | disqualified | over_quota | closed | redirect | outcome, "title", "body", "url", "showScore"}; the first thank_you ending is the default. The server refuses a definition that breaks a rule, and names it: conditions and recalls read only earlier questions, rules jump only forward, every path reaches an ending, keys are unique, a regex is RE2, and the largest response fits 64 KB. The layout draws everything inside <ProbeForm> from ‘parable/pages’, and every answer with <ProbeField questionKey="..." />. ProbeField draws the question with its Probe component, saves the answer, checks it and shows its error. Pass as only to pick another component for the same answer: text, paragraph, phone, fields, number, slider, choice, checkboxes, cards, dropdown, ranking, yes-no, consent, scale, rating, nps, matrix, best-worst, date, time, signature or click-map. ProbeWelcome, ProbeQuestions, ProbeSection, ProbeProgress, ProbeNav and ProbeEnding draw the parts around the questions, and useProbe() gives the phase, the sections on screen, the errors and next, back and submit. Never draw an input of your own, and never draw an input from ‘parable/panes/placeholders’ outside ProbeField. Arrange, group and style the Probe as the person asks. Parable draws the Example banner, who can read the answers, and why a Probe takes no answers now, above your layout. Use what Parable knows. Never ask for a name or an email: use a hidden field with source respondent and attribute name or email. People who run the Probe open, pause and close it, invite people, and set how it runs on its Participants Page (who answers, responses per person, changing a submitted response, withdrawing, anonymity, and when it closes); you do not. Who reads other people’s answers is the Probe Page’s view.responses Policy: by default Publishing and Primary. Those people see every answer in the Responses table of the Probe’s Participants Page. Plots cannot read Probe answers yet, so do not build results Plots over them. An anonymous Probe shows no answers until 3 people answered, and never shows who answered. A Probe that asks who the person is cannot be anonymous: a question with identifying true, a text box with format email or phone, or a multi_text preset name, address or contact.

Example: a Home Page that places a chart

This example is the Home Page half of the chart example in the Panes Power (see its Example section), which holds the Pane, its Plot and its Palette. Together they are a small, complete Parable that draws. The example compiles against the Pane types. In it, example is the Parable’s handle and home is the Page’s handle: write the real ones. The Home Page’s Perception declares the Panes it places and the Provider group that the chart’s Plot reads. The group names every Provider that the Plot reads:
The Page’s code takes the declared Panes from its props and places them:
When the Page already shows Panes, add the new Pane to its Perception and its layout, and keep the Panes it already shows. When the chart goes on a Page that is not Home, declare its Pane in that Page’s Perception, and put its Providers in the Home Page’s Provider groups: no other Page’s Perception names Providers (see the Perceptions Power). Related Powers: Panes, Pipelines, Packages, Perceptions, Palettes, Policies, Publishing. Find each by its title; do not guess stored names.