Object nodes

23 node types for working with plain objects, in the Object category (indigo, curly-brace icon): object.assign, plus 22 nodes covering the rest of JavaScript's Object.* static methods.

Usable both on the main canvas and inside a Function Graph.

Object Assign — object.assign

Merges one or more source objects into a target object, compiling to Object.assign(target, source0, source1, ...). An ordinary exec pass-through node (one exec-in, one exec-out, no forking) — structurally identical to the simple array methods like array.push.

• Inputs: in (exec) — "In"; target (value) — "Target"; source-0 (value) — "Source 0"; plus any number of additional "Source N" pins added on the node
• Outputs: out (exec) — "Next"; result (value) — "Result" (the merged object, i.e. the target modified in place)
• Config fields: none

Grow or shrink the source list directly on the node with the "+ Add Source" button; each dynamically-added source shows a "×" remove button. The static "Source 0" pin is always present and has no remove button. Every source pin (static and dynamic) supports inline literal editing when it isn't wired — type a default value directly on the pin.

const merged = Object.assign(target, source0, source1);

Sources are applied left-to-right, so a property present in a later source overrides the same property from an earlier one. Any source pin left unwired resolves to undefined, which Object.assign silently skips — so a node with extra sources you haven't wired yet still compiles and behaves correctly.

Use case: Combine several objects into one — for example, layering a set of default options with request-specific overrides, or merging a partial update into an existing record — without writing any raw JavaScript.

One-input nodes

14 nodes that take a single object and produce one result — one exec-in, one value-input pin, one exec-out, one value-output pin. No config fields on any of them. Structurally identical to array.push/array.pop, just backed by a different underlying method:

Node	Type	Input pin	Output pin	Compiles to
Object Keys	object.keys	Target	Keys	Object.keys(target)
Object Values	object.values	Target	Values	Object.values(target)
Object Entries	object.entries	Target	Entries	Object.entries(target)
Object From Entries	object.fromEntries	Iterable	Object	Object.fromEntries(iterable)
Object Get Own Property Names	object.getOwnPropertyNames	Target	Names	Object.getOwnPropertyNames(target)
Object Get Own Property Symbols	object.getOwnPropertySymbols	Target	Symbols	Object.getOwnPropertySymbols(target)
Object Get Own Property Descriptors	object.getOwnPropertyDescriptors	Target	Descriptors	Object.getOwnPropertyDescriptors(target)
Get Prototype Of	object.getPrototypeOf	Target	Prototype	Object.getPrototypeOf(target)
Prevent Extensions	object.preventExtensions	Target	Object	Object.preventExtensions(target)
Is Extensible	object.isExtensible	Target	isExtensible	Object.isExtensible(target)
Seal	object.seal	Target	Sealed Object	Object.seal(target)
Is Sealed	object.isSealed	Target	isSealed	Object.isSealed(target)
Freeze	object.freeze	Target	Frozen Object	Object.freeze(target)
Is Frozen	object.isFrozen	Target	isFrozen	Object.isFrozen(target)

Every input pin supports inline literal editing when left unwired ({} for every "Target"/object pin, [] for From Entries' "Iterable").

const objKeys = Object.keys(target);
const frozen = Object.freeze(target);
const alreadySealed = Object.isSealed(target);

Note on the boolean-producing nodes (Is Extensible, Is Sealed, Is Frozen): unlike Is Array, these still have execution pins rather than being pure value nodes — every Object node in this category compiles to a statement inside the execution chain, for consistency across the whole category, even where the underlying JS expression alone would have been enough. Wire the boolean result into a Branch node's Condition the same way you would any other value pin.

Use case: Inspect or lock down an object's shape — list its keys before iterating, freeze a config object so nothing downstream can accidentally mutate it, or check isFrozen/isSealed before deciding whether to attempt a write.

Two-input nodes

4 nodes that take two objects/values and produce one result — same exec-in/exec-out shape as the one-input nodes above, just with a second value-input pin. No config fields:

Node	Type	Input pins	Output pin	Compiles to
Get Own Property Descriptor	object.getOwnPropertyDescriptor	Target, Property	Descriptor	Object.getOwnPropertyDescriptor(target, prop)
Set Prototype Of	object.setPrototypeOf	Target, Prototype	Target	Object.setPrototypeOf(target, proto)
Object Is	object.is	Value 1, Value 2	isSame	Object.is(value1, value2)
Has Own	object.hasOwn	Target, Property	hasOwn	Object.hasOwn(target, prop)

const descriptor = Object.getOwnPropertyDescriptor(target, "name");
const same = Object.is(value1, value2);
const owns = Object.hasOwn(target, "name");

Object Is vs. ===: Object.is treats NaN as equal to itself and distinguishes +0/-0, unlike both === and the Equal operator node — reach for this node specifically when that distinction matters.

Use case: Look up a single property's full descriptor (writable/enumerable/ configurable, or a getter/setter) before deciding how to handle it, check for an own (non-inherited) property before reading it, or re-parent an object's prototype chain.

Object Create — object.create

Creates a new object with a given prototype, compiling to Object.create(proto) — or Object.create(proto, { ... }) if you fill in the optional descriptor field.

• Inputs: in (exec); proto (value) — "Proto" (defaults to {} unwired)
• Outputs: out (exec) — "Next"; result (value) — "Created Object"
• Config fields:

Key	Type	Default	Notes
propertiesObject	code	""	Optional raw JS property-descriptor object — the second argument to Object.create(). Left empty, only the one-argument form is emitted.

const created = Object.create(proto);
// or, with a propertiesObject filled in:
const created = Object.create(proto, { name: { value: "Ada", enumerable: true } });

Use case: Build an object that inherits from a specific prototype without going through a class or constructor function.

Object Define Property — object.defineProperty

Defines or modifies a single property on an object, compiling to Object.defineProperty(target, prop, descriptor), and returns the target.

• Inputs: in (exec); target (value) — "Target" (defaults to {} unwired); prop (value) — "Property" (defaults to "0" unwired)
• Outputs: out (exec) — "Next"; result (value) — "Target"
• Config fields:

Key	Type	Default	Notes
descriptor	code	"{}"	Raw JS property descriptor, e.g. { value: 42, writable: true, enumerable: true }. Supports get/set accessor functions, not just plain JSON.

const target = Object.defineProperty(target, "count", { value: 0, writable: true });

Use case: Add a non-enumerable or read-only property, or define a getter/setter — anything a plain assignment (target.count = 0) can't express.

Object Define Properties — object.defineProperties

Defines or modifies multiple properties at once, compiling to Object.defineProperties(target, descriptors), and returns the target.

• Inputs: in (exec); target (value) — "Target" (defaults to {} unwired)
• Outputs: out (exec) — "Next"; result (value) — "Target"
• Config fields:

Key	Type	Default	Notes
descriptors	code	"{}"	Object mapping property names to their descriptors, e.g. { name: { value: "Ada" }, age: { value: 30 } }.

const target = Object.defineProperties(target, {
  name: { value: "Ada", enumerable: true },
  age: { value: 30, enumerable: true },
});

Use case: Define several properties (with fine-grained writable/enumerable/ configurable control, or accessors) in a single call instead of chaining multiple Define Property nodes.

Object Group By — object.groupBy

Groups the elements of an iterable by the string key a callback returns for each one, compiling to Object.groupBy(iterable, callback).

• Inputs: in (exec); iterable (value) — "Iterable" (defaults to [] unwired); callback (value) — "Callback" (defaults to undefined unwired)
• Outputs: out (exec) — "Next"; result (value) — "Grouped"
• Config fields: none

const grouped = Object.groupBy(items, (item, index) => item.type);

The "Callback" pin expects a function value, not a wired execution body — wire in a Function node's function-reference output, or a "function"-typed variable's Get Variable node, the same function-as-value mechanism Callback uses. This is different from the Array loop-container nodes, which let you wire a visual loop body directly.

Use case: Bucket a list of records by a computed key — for example, grouping a list of users by role, or orders by status — into one object of arrays, without writing the grouping loop by hand.

Notes

• Every node in this category — including the boolean-producing ones (Is Extensible, Is Sealed, Is Frozen, Object Is, Has Own) — is an ordinary exec pass-through node with real execution pins, not a pure value node like array.isArray. This was a deliberate consistency choice across the whole Object category rather than special-casing the predicates.
• The descriptor/descriptors/propertiesObject config fields are raw JavaScript text, not parsed/validated JSON — this is what lets them describe accessor (get/set) properties, not just plain data values, at the cost of no inline structural validation.