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

Ten 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, 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.
• 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.
• All three graph kinds accept them — event, function, and macro — and so does a Blueprint Value graph. Memo again excepted: event and macro only.
• 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.

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.

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 typed json, not array, so it reaches Join, For Each, and any other json input — but not the Array … nodes.

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.

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.

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 by JSON value — 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

JSON-value equality, the same rule as Array Remove. This is deliberately looser than Equal in Math, which compares identity.

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 by value, 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, and where it was.

Array Filter By Key

blueprint.collection.arrayFilter · Pure

Every item whose key field equals value, 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, kept so existing graphs keep resolving. A value that is not an array gives 0. Use Array Length in new graphs.

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

These act on one field at a time, by name. They take no path — for a nested write use Set JSON Field. 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

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

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 Items.

Merge JSON Object

blueprint.data.jsonMergeObject · Pure

Shallow merge with b winning, identical to Object Merge. A non-object input is treated as {}.

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.

It is the one data output in the catalogue that may feed several consumers. Everything else is single-consumer, and for two different reasons: a pure node re-evaluates at every read, so one Random Float wired to three pins gives three 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.

Synchronous rather than latent on purpose: there is nothing to await, and a latent node would be barred from an inline story value. function graphs stay pure, so a Memo cannot go in one.