Data

Data holds the values a blueprint computes with. Reach for it when you need a constant, when a value arrives as the wrong type, or when you have to take apart a string, an array, or a JSON document. Almost nothing here has an exec pin — a Data node is read by whoever is wired to its output. Memo is the one exception, and it explains itself below.

Value types

These valueTypes appear on the pins below.

An edge between two data pins is allowed when the types are identical, or when one of these holds:

Types from other categories widen the same way and nowhere else: element connects to any element:nl.… pin and back, element pins do not connect to any in either direction, and ImageAsset and string both reach an ImageAsset|null input.

Everything else is refused, including the reverses authors expect to work:

• json → array, json → Rect. Every widening rule runs one way only. An arbitrary object is not a rectangle.
• json → a struct. An object whose fields are not declared, such as the result of Parse JSON, does not connect to Get Field. Read it with Get JSON Field.
• float → integer. Insert To Integer, which truncates toward zero.
• string → integer or float. Insert Parse Int, Parse Float, To Integer, or To Float.
• boolean → string, json → string. Only numbers coerce to text. Insert To String or Stringify JSON.
• string, integer, float, boolean → json. array and Rect are the only types that reach a json input implicitly. Insert To JSON.
• RGBAColor → json, Vector2D → json. They are structured types of their own, not JSON documents. Take them apart with Break Vector2D, or build a document with Make Object.

Conventions

• Every node here is pure but one. There are no exec pins to connect, so a Data node cannot sit on the execution path. Its output is computed when a consumer reads it, and recomputed on the next read. Memo is the exception: it is an exec node, because holding a value still is exactly what a pure node cannot do.
• A Blueprint Value graph accepts all of them, Memo included.
• Nothing is modified in place. A node that writes returns a new value on its output pin and leaves its input alone.
• On-card literals exist for string, integer, float, and boolean pins only. A json or array input has no on-card editor; feed it a JSON literal or a Make Object / Make Array node.
• An unwired input is not an error. It reads the pin's on-card literal, or nothing when there is none, and each node normalizes: a missing array reads as empty, a missing string as "", a missing number as 0.
• A chain of pure nodes resolves at most 32 links deep. Past that the read returns nothing, silently.
• Some nodes are grouped into families. While the palette is browsed, each of these is one row: the literals from String to Rect (Literal), the conversions from To String to To JSON (Convert Type), the type tests from Is String to Is Null (Check Type), Trim, Trim Start and Trim End (Trim Whitespace), To Upper Case, To Lower Case and Capitalize (Change Case), Replace and Replace All (Replace Text), and Pad Start and Pad End (Pad Text). A search finds each node by its own name, and the ▾ beside a placed card's title switches it to another node of its family. See Node families.

Literals

A literal has one output pin and an on-card field. Its type is fixed by the node you pick, which is what makes the rest of the graph type-check.

String

blueprint.data.stringLiteral · Pure

On-card fields

Integer

blueprint.data.integerLiteral · Pure

On-card fields

Float

blueprint.data.floatLiteral · Pure

On-card fields

Boolean

blueprint.data.booleanLiteral · Pure

On-card fields

Null

blueprint.data.nullLiteral · Pure

The only literal with no on-card field — there is nothing to configure about null. Its output is typed json, so it reaches any json or any input.

JSON

blueprint.data.jsonLiteral · Pure

The card shows the root type and a summary; editing opens a tree form with named fields for an object and ordered entries for an array. A new node starts as an empty object.

On-card fields

Color

blueprint.data.colorLiteral · Pure

Edited with a color picker and shown as 8-digit RGBA hex. The output is always the normalized { r, g, b, a } record — r, g, b as bytes, a from 0 to 1.

On-card fields

Vector2D

blueprint.data.vector2dLiteral · Pure

On-card fields

Rect

blueprint.data.rectLiteral · Pure

Like Color and Vector2D, Rect is a type of its own. Unlike them, it also widens into json, so it still connects to any json input — see the note under Value types.

On-card fields

Number

blueprint.data.numberLiteral · Pure

The legacy number constant, hidden from the palette so it cannot be added to a new graph. It stays registered so old graphs keep resolving. Use Float.

On-card fields

Literal

blueprint.data.literal · Pure

The legacy untyped constant, also hidden from the palette. Its any output type-checks against everything, which is exactly why the typed literals replaced it.

On-card fields

Conversion

These are the nodes the connection rules send you to. None of them fail: an input that cannot be read produces the type's zero value rather than an error.

To String

blueprint.string.toString · Pure

null and an unwired input both read as "". An object or an array is serialized to JSON text.

To Integer

blueprint.data.toInteger · Pure

Truncates toward zero — -2.7 becomes -2, not -3. true reads as 1, false as 0, a numeric string is accepted, and anything else gives 0.

To Float

blueprint.data.toFloat · Pure

Same acceptance as To Integer, without the truncation. A value that is not a finite number gives 0.

To Boolean

blueprint.data.toBoolean · Pure

Strings are matched after trimming and lowercasing: "", "false", "0", and "no" are false; "true", "1", and "yes" are true; any other non-empty string is true. 0 and a non-finite number are false.

To JSON

blueprint.data.toJson · Pure

A string is parsed as JSON, and kept as the original string when it does not parse — so this node never destroys text. Other values are made JSON-safe: a non-finite number and a cycle become null, a function or symbol becomes its text form.

Parse Int

blueprint.data.parseInt · Pure

Base 10, and the leading number wins — "12px" gives 12. No digits at all gives 0.

Parse Float

blueprint.data.parseFloat · Pure

Parse JSON

blueprint.data.parseJson · Pure

Strict: text that does not parse, and an empty string, both give null. Use To JSON instead when you would rather keep the original text.

Stringify JSON

blueprint.data.stringifyJson · Pure

An unwired input gives the text "null". A value that cannot be serialized gives "".

Type tests

Each takes any and answers a question about the value that actually arrived, which is how you find out what a json or any pin is really carrying.

Is String

blueprint.data.isString · Pure

Is Number

blueprint.data.isNumber · Pure

Finite numbers only — NaN and the infinities are false, and so is a numeric string. This asks about the type, not about parseability.

Is Boolean

blueprint.data.isBoolean · Pure

Is Array

blueprint.data.isArray · Pure

Is Object

blueprint.data.isObject · Pure

True for a non-null object that is not an array. An array answers Is Array, not this.

Is Null

blueprint.data.isNull · Pure

True for null, and also for an input that resolved to nothing — an unwired pin reads as null here.

Not Null

blueprint.data.notNull · Pure

The negation of Is Null, so you do not have to hang a Not off it.

Is Empty Value

blueprint.data.isEmptyValue · Pure

True for null, "", an empty array, and an empty object. 0 and false are values, not emptiness, and both answer false.

Strings

Every value input here takes an on-card literal, so a one-off string does not need its own literal node. Indices are zero-based, and out-of-range indices are clamped rather than rejected.

Concat

blueprint.string.concat · Pure

Joins its inputs in pin order with nothing between them. The card has an add-input control: beyond a and b you can append further string inputs, and the signature below shows only the two it starts with.

Format

blueprint.string.format · Pure

Replaces {name} in the template with the matching field of values, or {0}, {1} … when values is an array. A placeholder with no match becomes empty, and every placeholder becomes empty when values is neither an object nor an array.

Format is the one formatter the palette offers, and it works in a Blueprint Value and in a function. For a template in the player's language, wire Translation Key Text into template.

Length

blueprint.string.length · Pure

Is Empty

blueprint.string.isEmpty · Pure

Length zero. A string of spaces is not empty — that is Is Blank.

Is Blank

blueprint.string.isBlank · Pure

Empty, or nothing but whitespace.

Trim

blueprint.string.trim · Pure

Trim Start

blueprint.string.trimStart · Pure

Trim End

blueprint.string.trimEnd · Pure

To Upper Case

blueprint.string.toUpperCase · Pure

To Lower Case

blueprint.string.toLowerCase · Pure

Capitalize

blueprint.string.capitalize · Pure

Upper-cases the first character and leaves the rest exactly as it is — this is not title case.

Equals

blueprint.string.equals · Pure

Equals Ignore Case

blueprint.string.equalsIgnoreCase · Pure

Contains

blueprint.string.contains · Pure

Starts With

blueprint.string.startsWith · Pure

Ends With

blueprint.string.endsWith · Pure

Index Of

blueprint.string.indexOf · Pure

Searches forward from start and gives -1 when there is no match. start is clamped into the string, so an out-of-range value searches from the beginning or the end rather than failing.

Last Index Of

blueprint.string.lastIndexOf · Pure

Searches backward from the end. There is no start pin — that is the one asymmetry with Index Of.

Count

blueprint.string.count · Pure

Counts non-overlapping occurrences. An empty search gives 0, not the string length.

Char At

blueprint.string.charAt · Pure

An index outside the string gives "", not an error.

Substring

blueprint.string.substring · Pure

The second pin is a length, not an end index. Both are clamped into the string, and an unwired length takes everything from start onwards.

Insert

blueprint.string.insert · Pure

index is clamped into the string, and an index that cannot be read appends at the end.

Replace

blueprint.string.replace · Pure

Replaces the first occurrence only. An empty search returns the value unchanged rather than splicing at every position.

Replace All

blueprint.string.replaceAll · Pure

Every occurrence. search is plain text, not a pattern — an empty search again returns the value unchanged.

Repeat

blueprint.string.repeat · Pure

count is clamped to 0–10000, so a runaway number cannot build an unbounded string.

Pad Start

blueprint.string.padStart · Pure

length is the target total length, not the number of characters to add. A string that is already long enough comes back unchanged.

Pad End

blueprint.string.padEnd · Pure

Split

blueprint.string.split · Pure

The result is an array of strings. It reaches the Array … nodes as well as Join, For Each and any other json input.

Join

blueprint.string.join · Pure

Takes json, unlike Array Join, which takes array. A values that is not an array gives "".

Matches Regex

blueprint.string.matchesRegex · Pure

pattern is the expression source with no delimiters and no flags. A pattern that does not compile gives false rather than raising.

Extract Regex

blueprint.string.extractRegex · Pure

Returns the first capture group when the pattern has one, otherwise the whole match. No match, or a pattern that does not compile, gives "".

Normalize Line Breaks

blueprint.string.normalizeLineBreaks · Pure

Rewrites \r\n and lone \r to \n, so text pasted from any platform compares and splits consistently.

Arrays

Every one of these reads its array input as an array and substitutes an empty one when it is not, so nothing throws. Every one that writes returns a new array on result.

When the type of the items is known, as with the endings from Get Endings, the nodes that return an array return the same type, and Array Get, Array First, Array Last and Array Find By Key return one item of that type: Array Filter By Key on endings gives endings, and Array First gives one ending. Array Concat takes the type of a.

Array Length

blueprint.collection.arrayLength · Pure

Array Get

blueprint.collection.arrayGet · Pure

An index that is negative or past the end gives null. The output is json because an array element can be any JSON value, and takes the item type when the items are known.

Array Set

blueprint.collection.arraySet · Pure

Writes at index and returns the new array. A negative index, or one above 10000, returns the input unchanged; an index past the end extends the array, leaving the skipped slots empty.

Array Push

blueprint.collection.arrayPush · Pure

Appends to the end.

Array Insert

blueprint.collection.arrayInsert · Pure

index is clamped to 0–length, so an out-of-range index appends rather than failing.

Array Remove

blueprint.collection.arrayRemove · Pure

Removes the first item equal to item, compared as Equal compares: two objects with the same fields match, even though they are different objects. No match returns the input unchanged.

Array Remove At

blueprint.collection.arrayRemoveAt · Pure

Removes one item and closes the gap. An out-of-range index returns the input unchanged.

Array Contains

blueprint.collection.arrayContains · Pure

True when an item equals item, compared as Equal compares, the same rule as Array Remove.

Array Slice

blueprint.collection.arraySlice · Pure

end is exclusive. Both bounds are clamped into the array, and an unwired end runs to the end.

Array Join

blueprint.collection.arrayJoin · Pure

Converts each item to text — objects and arrays become JSON — and joins them. Takes array, where the string Join takes json.

Array First

blueprint.collection.arrayFirst · Pure

Array Last

blueprint.collection.arrayLast · Pure

Array Is Empty

blueprint.collection.arrayIsEmpty · Pure

Array Index Of

blueprint.collection.arrayIndexOf · Pure

The position of the first item equal to item, compared by value the way Array Contains compares. -1 when nothing matches.

Array Concat

blueprint.collection.arrayConcat · Pure

a followed by b, as a new array.

Array Reverse

blueprint.collection.arrayReverse · Pure

Array Unique

blueprint.collection.arrayUnique · Pure

Drops later duplicates, keeping the first of each. Items are compared as Equal compares them, so two objects with the same fields count as one.

Array Range

blueprint.collection.arrayRange · Pure

count numbers starting at start, each one step further on. The array a page needs when it has to draw N of something and the numbers are the content.

Array Find By Key

blueprint.collection.arrayFind · Pure

The first item whose key field equals value, compared as Equal compares, and where it was.

Array Filter By Key

blueprint.collection.arrayFilter · Pure

Every item whose key field equals value, compared as Equal compares, in their original order.

Array Sort By Key

blueprint.collection.arraySort · Pure

Orders records by one of their fields. The three key-based nodes take a field name rather than a comparator, because a comparator is a function value and sorting records by one of their fields is what a list actually needs.

Numbers compare as numbers, booleans as false before true, and everything else as text, ordered the way the runtime collates strings. Items whose field is missing, null, or "" sort to the end in both directions, and ties keep the order they arrived in. An empty key returns the array unchanged.

JSON Array Length

blueprint.data.jsonArrayLength · Pure

The older name for Array Length, hidden from the palette and kept so existing graphs keep resolving. A value that is not an array gives 0. Use Array Length in new graphs.

Structs

A struct is an object whose fields are declared: an ending, a history entry, a save entry, a gallery entry, or a row of a List. A pin that carries one shows the struct's name on the card, such as Ending, and a pin that carries an array of them shows Ending list. Get Field reads one field, picked from a dropdown.

The fields are described with the node that hands them out. A plugin can declare the structs its own nodes hand out, such as the Gallery's Gallery entry; see Manifest. The rows of a List have the struct set under Edit content, which is one of the structs above or the fields written for that List; see Lists.

• The type follows the wires. The array nodes pass the item type on, as described under Arrays. For Each in Flow gives one item of the array it walks. The List nodes and the item heads give and take rows of the List's struct; see List.
• A field's type becomes the pin's type. A String field gives string, Number float, Boolean boolean, Image ImageAsset|null, Color RGBAColor and JSON json.
• Dragging a wire off a struct. Release a wire dragged from a struct pin on empty canvas, and the add-node menu opens on Fields, which lists Get for each field, such as Get isReached. A wire dragged from an array of structs lists Filter by, Sort by and Find by for each field, such as Filter by isReached. Each entry adds the node with the field already chosen and wires it to the pin. Filter by and Find by on a boolean field compare against True.
• A field the struct does not have is reported. A Get Field set to a field the struct lacks, and a key on Array Filter By Key, Array Sort By Key or Array Find By Key that names no field of the items, are warnings on the canvas and the project check Field not in shape (blueprint/field-missing). Such a node reads nothing: Get Field gives an empty value, a filter keeps no items, and a sort keeps the order. This happens after a List's field is deleted or a key is typed by hand. Only nodes whose struct is known are checked.

Get Field

blueprint.list.getItemField · Pure

One field of a struct. Wire the struct into Object and pick the field under Field. The output takes the field's type, so isReached from an ending wires straight into Branch.

On-card fields

• The first struct wired in is kept. From then on Object accepts only that struct, even after its wire is removed. To read another struct, add another Get Field.
• Inside a List row, Object can stay unwired. The node then reads the row being drawn, and the card shows Object · Current row. A row is in reach in the places listed under List: the blueprints of the elements in the List's item template, the List's own item heads, and component definitions.
• Unwired anywhere else, it reads nothing. The card reports Object as not connected. A Get Field that kept a struct and lost its wire also reads nothing; it does not read the row instead.
• An object without declared fields does not connect. Read it with Get JSON Field.

The node was named Get Item Field and read only List rows. Its type id is unchanged, so graphs that hold it keep the node, and one left unwired in a row reads the row as before.

Geometry

Vector2D and Rect are structured types rather than JSON documents, so they are built and taken apart with nodes of their own rather than with Get JSON Field. Every input reads a non-number as 0.

Make Vector2D

blueprint.data.makeVector2d · Pure

Unlike the Vector2D literal, both components can be wired — which is what Move Mouse To wants when the point is computed.

Break Vector2D

blueprint.data.breakVector2d · Pure

Make Rect

blueprint.data.makeRect · Pure

A negative width or height is normalized rather than kept: the origin moves and the extent is made positive, so the rectangle you get is the one you drew.

Break Rect

blueprint.data.breakRect · Pure

Rect Center

blueprint.data.rectCenter · Pure

The point equidistant from the rectangle's four edges.

Objects

Object Keys and Object Values read an object's top level, and Object Merge combines two objects. To write or remove a field, use Set JSON Field or Remove JSON Field under JSON, which take a path. An input that is not an object is read as {}.

Object Keys

blueprint.collection.objectKeys · Pure

Field names in insertion order. An array or any other non-object gives an empty array.

Object Values

blueprint.collection.objectValues · Pure

Object Set Field

blueprint.collection.objectSetField · Pure

Superseded by Set JSON Field, which takes a path and so also reaches nested fields; hidden from the palette but still runs in graphs that hold it. field is a plain name, and a dot in it is part of the name rather than a path step. A blank name returns the copy unchanged.

Object Remove Field

blueprint.collection.objectRemoveField · Pure

Superseded by Remove JSON Field; hidden from the palette but still runs in graphs that hold it.

Object Merge

blueprint.collection.objectMerge · Pure

Shallow merge; b wins on a collision. Nested objects are replaced, not merged. Merge JSON Object is the same operation under a second type id.

JSON

The path nodes address a document with dot notation: user.profile.name, and a numeric segment for an array index, items.0. Escape a literal dot in a key as \.. An empty path means the whole document, so Set JSON Field with no path replaces it outright.

Get JSON Field

blueprint.data.jsonGet · Pure

A path that does not exist gives null, so a missing field and a field holding null read the same. Use Has JSON Field when the difference matters.

Has JSON Field

blueprint.data.jsonHas · Pure

Presence, not truthiness: a field whose value is null still exists.

Set JSON Field

blueprint.data.jsonSet · Pure

Copies the input and writes into the copy. Missing containers along the path are created — an array when the next segment is a number, an object otherwise — so writing stats.hp into an empty document produces { "stats": { "hp": … } }.

Remove JSON Field

blueprint.data.jsonRemove · Pure

Deletes an object field, or splices out an array entry so the later items shift down. A path that does not exist gives back the copy unchanged.

Make Object

blueprint.data.jsonMakeObject · Pure

Builds an object from dynamic pin pairs, so the signature below is only the output. Each field on the card adds a Name input (string, takes an on-card literal) and a Value input (any); a new node starts with one pair. Names are read at run time, so a wired Name computes the key. A field whose name is blank, or repeats an earlier name, is skipped.

Make Array

blueprint.data.jsonMakeArray · Pure

Builds an array from dynamic Item inputs in pin order, so the signature below is only the output. A new node starts with none — add them on the card. This is the node that produces the array type, and therefore the way to hand a built array to Array Length or List's Set List Content.

Merge JSON Object

blueprint.data.jsonMergeObject · Pure

Shallow merge with b winning, identical to Object Merge. A non-object input is treated as {}. Superseded by Object Merge; hidden from the palette but still runs in graphs that hold it.

Clone JSON

blueprint.data.jsonClone · Pure

A deep, JSON-safe copy. The writer nodes already copy their input, so you only need this when you are about to hand the same document to two branches that must not see each other's edits.

Holding a value

Memo

blueprint.data.memo

Reads its input once, when execution passes through, and keeps that value on its output until the next time execution passes through. Before the first pass the output reads null. The value is kept in the same store as the blueprint's variables: one held during Init is still there for a later Mouse Click, and it starts over when that owner instance does.

Its output may feed several consumers. A computed data output feeds only one, and a second wire from it replaces the first, for two different reasons: a pure node re-evaluates at every read, so the same Random Float read twice gives two numbers; and an exec node's output belongs to the pulse that produced it. A Memo has exactly one writer — itself — so every read returns what that write left, and fanning it out cannot surprise anybody. The literals on this page, Element bindings and the parameter pins of an Fn fan out as well, because every read of them gives the same value.

Synchronous rather than latent on purpose: there is nothing to await, and a latent node would be barred from an inline story value.