Divooka.CoreEngine
Parcel.CoreEngine.Contracts.IFrontendImplementedNode
Provides formal definition for front-end implemented nodes, e.g. literals, etc.
Parcel.CoreEngine.Contracts.NodeTargetDescriptor
Provides detailed information regarding node type binding/endpoint/target type definition, mostly to inform both the runtime engine and front end what the target type is and where to find it
Remarks
TODO: Consider merge this with NodeTargetPathProtocolStructure, though do notice this is intended to be a plain generic data-only descriptor, and we DO NOT wish this to be bound to regex parsing protocol.
Parcel.CoreEngine.Contracts.NodeTargetDescriptor.Runtime
Every node has a unique target runtime
Parcel.CoreEngine.Contracts.NodeTargetDescriptor.UniqueParcelName
A human readable name for the target type that's guaranteed to be unique among all nodes in the Parcel ecosystem.
Those are only available for "official" nodes, and not all nodes have such a name.
All those names will be available in some central registry.
A general format for such names shall be: Domain.Category.Node.Variant
Parcel.CoreEngine.Contracts.NodeTargetDescriptor.Aliases
A node might have a bunch of aliases for searching purpose.
Parcel.CoreEngine.Contracts.NodeTargetDescriptor.DefaultDisplayName
A node may have a default display name
Parcel.CoreEngine.Contracts.NodeTargetDescriptor.Namespace
For nodes defined in C#, they must have a namespace
Parcel.CoreEngine.Contracts.NodeTargetDescriptor.Module
Assembly in C#, module in Python
Parcel.CoreEngine.Contracts.NodeTargetDescriptor.DeclaringType
For types and C# functions, they all have an encapsulating class container;
For Python, methods can reside in files at global/module scope, so this would be null.
Parcel.CoreEngine.Contracts.NodeTargetDescriptor.TargetName
Type, method, property
Parcel.CoreEngine.Contracts.NodeTargetDescriptor.IsNodeMemberProperty
The node is referencing into a member property of a typed instance
Parcel.CoreEngine.Contracts.NodeTargetDescriptor.IsNodeInstanceFunction
The node is a call into instance function
Parcel.CoreEngine.Contracts.NodeTargetDescriptor.IsNodeGlobalFunction
The node refers to a static function
Parcel.CoreEngine.Contracts.NodeTargetDescriptor.IsNodeObjectInstance
The node refers to a type and will instantiate an instance of that type
Parcel.CoreEngine.Contracts.NodeTargetDescriptor.IsNodeTypeDefinition
Parcel supports meta-programming and declaration-style type definitions; In such cases, it's dynamically generating and defining new types
Parcel.CoreEngine.Contracts.NodeTargetDescriptor.FullTargetPath
Globally unique single-string identifier for the target; A combination (the "Protocol") of values above.
Parcel.CoreEngine.Contracts.NodeTargetDescriptor.ShortestTargetPath
Globally unique shortest single-string identifier for the target.
Parcel.CoreEngine.Contracts.ParcelNodeRuntimeExceptionBase
Base exception for runtime user-facing application-level node-related exceptions (i.e. non-runtime/engine-level/implementation exceptions)
Parcel.CoreEngine.Contracts.PluginMetadata.Serialize()
Serializes the PluginMetadata to a file in the specified format.
Parameters
| Name | Description | Default |
|---|---|---|
filePath |
The file path to save the metadata. |
Parcel.CoreEngine.Contracts.PluginMetadata.Deserialize()
Deserializes the PluginMetadata from a file in the specified format.
Parameters
| Name | Description | Default |
|---|---|---|
filePath |
The file path to read the metadata from. |
Returns
A new instance of PluginMetadata with populated fields.
Parcel.CoreEngine.Contracts.SystemNodes.CoreTestEmptyTarget
An empty target, used for testing purpose; May be used for attaching arbitrary attributes to nodes that are not visible in front-ends.
Parcel.CoreEngine.Contracts.SystemNodes.ReservedNodeTargetNames
Those are the reserved names of certain nodes serving special functions to the runtime
TODO: Can we make those unique names even shorter?
Parcel.CoreEngine.Contracts.SystemTags
Reserved names for tags
Parcel.CoreEngine.Contracts.SystemTags.AnnotationTag
Indicates an annotation node
Parcel.CoreEngine.Conversion.StringTypeConverter.ConvertValue()
Borrowed from Pure CLI library
Parcel.CoreEngine.DependencySolver.NodeExecutionQueueSolver
Given abstract connection information and node type (functional vs procedural), this solver resolves and outputs a list of nodes to be executed in the correct order.
This class takes in ParcelDocument for simplicity, but internally it doesn't depend on such structure should be able to take in any abstract connection information.
Parcel.CoreEngine.DependencySolver.ExecutionLayer
A tree-like structure but from execution order layers.
Sorting a set of nodes into evaluation layers based on their dependencies while ensuring nodes are evaluated as late as possible (i.e., as close as possible to when they are needed).
The left-most (first) layer is the "bottom/leaf" nodes that has no dependency.
The right-most (last) layer is the final (root) nodes that depends on everything.
Remarks
Assuming no cyclic dependency.
Parcel.CoreEngine.DependencySolver.ExecutionLayer.SortDependencyGraph()
Implement topological sort
Parcel.CoreEngine.DependencySolver.ExecutionQueue
The execution queue is for solving dependancy for functional nodes.
Assumes no cyclic dependency.
Parcel.CoreEngine.DivookaStandardDocumentBase
A representation of Parcel NExT node graph.
Parcel.CoreEngine.Document.DivookaStandardNode
Representation of a context-free Divooka Node. Suitable for serialization.
Provides some helper functions related to standard parsing, meta-data comprehension and information extraction.
Remarks
Remark-cz: Keep it clean and implicit. No need for additional adnorments or information.
Parcel.CoreEngine.Document.DivookaStandardNode.DivookaStandardNodeConnection
Represents a strongly typed connection.
Remarks
This is not used directly in serialization but it's a useful intermediate helper construct.
TODO: At the moment this class is just a placeholder, pending helper and supporting algorithms.
Parcel.CoreEngine.Document.DivookaStandardNode.SubgraphNodes
Remarks
A Divooka Graph node may directly contain documents/graphs inside.
Parcel.CoreEngine.Document.DivookaStandardNode.GetInputAttributes
Returns
Attribute names not trimmed.
Parcel.CoreEngine.Document.DivookaStandardNode.GetOutputAttributes
Returns
Attribute names not trimmed.
Parcel.CoreEngine.Document.DivookaStandardNode.OutboundConnections
May be used by some front-ends; May not always be available.
Core algorithms shouldn't depend on this.
Parcel.CoreEngine.Document.DivookaStandardNode.NodeID
Unique node ID in document.
Parcel.CoreEngine.Document.DivookaStandardNode.HasInputs
Checks whethere a node has input dependancies.
Remarks
Notice an input attribute (a front-end concept) is different from an actual input connection.
Parcel.CoreEngine.Document.DivookaStandardNode.GetInputNodes()
Gets the input nodes connected to any of the attributes to this node.
Parcel.CoreEngine.Helpers.BinarySerializationHelper
A curated interface to Parcel.CoreEngine.Helpers.CustomBinarySerializer
Parcel.CoreEngine.Helpers.CustomBinarySerializer
Advanced controlled binary serialization helper for dealing with automatic type serialization and discovery.
Kind of like our own YAML.Net or (now legacy) BinaryFormatter implementation, but with more controls and used in a more confined manner.
Remarks
This type depends on System.Reflection and is not AoT friendly.
TODO: May consider turning this into an instance class and allow passing in a custom dictionary of assembly classes for look up purpose.
Parcel.CoreEngine.Helpers.CustomBinarySerializer.PrimitiveGraphInputOutputTypes
Divooka graph native types; Notice this is intentionally reduced/minimized.
Parcel.CoreEngine.Helpers.CustomBinarySerializer.PrimitiveTypes
C# primitive types.
Parcel.CoreEngine.Helpers.CustomBinarySerializer.TypeToShortName
Map well-known primitives to short names
Parcel.CoreEngine.Helpers.CustomBinarySerializer.ShortNameToType
Reverse lookup to quickly get Type by short name
Parcel.CoreEngine.Helpers.CustomBinarySerializer.Serialize()
Serialize an object (that has a default constructor) into byte[]
Parameters
| Name | Description | Default |
|---|---|---|
obj |
Must have default constructor or is primitive. |
Parcel.CoreEngine.Helpers.CustomBinarySerializer.Deserialize()
Deserialize an object from the given byte[]
Parcel.CoreEngine.Helpers.CustomBinarySerializer.WriteObject()
Writes an object to the BinaryWriter recursively.
Parcel.CoreEngine.Helpers.CustomBinarySerializer.ReadObject()
Reads an object from the BinaryReader (recursively).
Parcel.CoreEngine.Helpers.CustomBinarySerializer.WriteNullableString()
Custom string encoding with length prefix + UTF8 bytes;
This can handle "null".
Parameters
| Name | Description | Default |
|---|---|---|
writer |
||
value |
Parcel.CoreEngine.Helpers.CustomBinarySerializer.IsPrimitiveOrString()
Check if type is built-in numeric/boolean/string/datetime/decimal, etc.
Remarks
Consider merging with Parcel.CoreEngine.Helpers.TypeHelper.IsTypePrimitiveSerializable()
Parcel.CoreEngine.Helpers.PreviewTextSerializationHelper
A curated interface for our custom text-based serialization.
Parcel.CoreEngine.Helpers.CustomTextSerializer
Advanced controlled serialization helper for text-based serialization.
The approach is similar to CustomBinarySerializer, but instead of writing binary data,
we write a custom line-based format. Not AoT friendly.
Remarks
This uses reflection so it not AoT compatible.
Parcel.CoreEngine.Helpers.CustomTextSerializer.TypeToShortName
A partial overlap with the short-name dictionary from CustomBinarySerializer.
Adjust to suit your usage.
Parcel.CoreEngine.Helpers.CustomTextSerializer.Serialize()
Serialize an object to a text string (line-based).
Parcel.CoreEngine.Helpers.CustomTextSerializer.Deserialize()
Deserialize an object from a text-based string (line-based).
Parcel.CoreEngine.Helpers.CustomTextSerializer.WriteObject()
Write an object to the text stream.
Parcel.CoreEngine.Helpers.CustomTextSerializer.ReadObject()
Read an object from the text stream.
Parcel.CoreEngine.Helpers.CustomTextSerializer.WriteCollection()
Write a collection or array to the text stream.
Parcel.CoreEngine.Helpers.CustomTextSerializer.ReadCollection()
Read a collection or array from the text stream.
Parcel.CoreEngine.Helpers.CustomTextSerializer.WriteNullableString()
Writes a string with a length prefix.
If
null, we write -1.
Otherwise: write length, then the string data.
(This is one of many ways to handle multi-line or "any possible char" strings in text.)
Parcel.CoreEngine.Helpers.CustomTextSerializer.ReadNullableString()
Reads a string with the same length prefix approach.
Parcel.CoreEngine.Helpers.SerializationHelper.Serialize()
Remarks
Notice this must be used with GetString - it cannot be used with BinaryReader.ReadString()!
Parcel.CoreEngine.Helpers.SerializationHelper.SerializeNullableString()
Remarks
Parcel.CoreEngine.Helpers.SerializationHelper.Concatenate()
Concatenate byte[] chunks into a single byte[].
Remarks
For counterpart, just do LINQ Take, or use a MemoryStream with BinaryReader.
Although, be careful that things serialized using SerializationHelper should generally be retrieved use it as well - for complete reliable custom control, don't use this, use MemoryStream with BinaryWriter instead (see WAVAudioPayload for an example).
Parameters
| Name | Description | Default |
|---|---|---|
chunks |
An array of byte arrays to concatenate. |
Returns
A single byte array containing all the bytes from the chunks.
Parcel.CoreEngine.Helpers.SerializationHelper.ConvertYAMLToJSON()
Converts JSON string to YAML string
Parameters
| Name | Description | Default |
|---|---|---|
yaml |
YAML input |
Returns
JSON output
Parcel.CoreEngine.Helpers.SerializationHelper.ConvertJSONToYAML()
Converts JSON string to YAML string.
Parameters
| Name | Description | Default |
|---|---|---|
json |
JSON input. |
Returns
YAML output.
Parcel.CoreEngine.Helpers.TypeHelper.IsNumericalType()
Check whether a type can represent number, which is parcel defaults to double
Parcel.CoreEngine.Helpers.TypeHelper.IsSimpleType()
Helper to check if it's a "simple"/primitive. type
Parcel.CoreEngine.Helpers.TypeHelper.CanConvert()
Remarks
Mostly used for connectability check.
The implementation of this function should be in sync to Parcel.CoreEngine.Helpers.TypeHelper.TryConvert(), but usually it's harmless if it's out of sync a bit - user can still make the connection.
Parcel.CoreEngine.Helpers.TypeHelper.TryConvert()
Provide plain text-based conversion.
Remarks
Try to keep this straightforward and lightweight as it's likely going to be invoked a lot.
In other situations, also may consider use `FindParseMethod` when the situation dictates. See Divooka.Framework.ViewModels.BaseNodes.AutomaticDataflowProcessorNode.CreateConnector for an example.
Parcel.CoreEngine.Helpers.TypeHelper.TryParse()
Given string representation of some data, try to automatically convert to a strongly defined type based on priorities.
This function always suceeds because in the worst case we just return a string.
Parcel.CoreEngine.Helpers.TypeHelper.GetImplicitConversionsTo()
Finds all public implicit conversion operators that return the given type.
Notice this finds only converters defined on the type - converters could also exist on source types.
Parcel.CoreEngine.Helpers.TypeHelper.GetEnumerableElementType()
Retrieve element type for "sequential" elements including arrays and generic collections.
Remarks
Generally applicable on System.Collections.IEnumerable interface children types.
Parcel.CoreEngine.Helpers.TypeHelper.GetMethod()
Finds a method on given type by name, parameter types, and return type.
Remarks
When multiple implicit operators take exactly the same parameter type, simply specifying the parameter list in GetMethod(...) is not enough. E.g. Reflection will see two op_Implicit methods that both accept a single Vector for different return types, and it cannot distinguish them by return type (notice this is generally true with all kinds of things when it comes to function overloading but the way we use implicit conversion makes this distinction important).
Parameters
| Name | Description | Default |
|---|---|---|
type |
The type to find the method on. | |
name |
The name of the method (e.g., "op_Implicit"). | |
inputTypes |
An array of parameter types that the method must match. | |
outputType |
The return type the method must produce. | |
bindingFlags |
Adjust binding flags depending on if the method is static/instance, public/non-public, etc. |
Returns
A System.Reflection.MethodInfo representing the matching method if found; otherwise,
null.
Parcel.CoreEngine.InstructionSets.InstructionSetMapping.ParcelCustomNameMappings
Remarks
A fully automatic FRONTEND should be able to identify ALL known names and map to correponding assemblies (and use defaults if necessary).
This is NOT to be handled by the engine/backend!
Parcel.CoreEngine.Messaging.StandardDeserialization
Provide counterpart for StandardSerialization
Parcel.CoreEngine.Messaging.StandardSerialization
Provide standard text-based serialization servics for Parcel objects
Parcel.CoreEngine.Metadata.PackageMetadata
Placeholder for package definition
Parcel.CoreEngine.MiniParcel.MicroParcelService
A simple line-based parser serving as DSL for Divooka graphs.
Remarks
(20250605) At the moment this seemed like neither well defined nor implemented at all. It's not line-based (like OBJ or CLI format), and its ReferentialBuldTests unit test is not working and syntax is not clear.
Parcel.CoreEngine.MiniParcel.MiniParcelService
A multiline custom syntax DSL for Divooka.
Parcel.CoreEngine.MiniParcel.MiniParcelService.NodeIndex
Represents node index given any node name for MiniParcel commands.
Remarks
WIP; Pending merge with existing data structures
Parcel.CoreEngine.MiniParcel.MiniParcelService.ParseAsNode()
Get raw fully expanded node definition from currently available context
Parcel.CoreEngine.MiniParcel.MiniParcelService.ResolveTarget()
Provides full standardized target name from conventional/shorthand names
Parcel.CoreEngine.Primitives.Bound
Defines an abstract 2D boundary
Parcel.CoreEngine.Primitives.GraphInputOutputDefinition.Comment
Any comment for the entry; Used for graph documentation purpose.
Parcel.CoreEngine.Serialization.SectionedBinaryWriter
Similar to BinaryWriter and offers the exact API except this class also does some bookkeeping, so it's possible to inspect, dump and document the file format structure.
Internally it uses BinaryWriter to write to the buffer and eventually the underlying.
Parcel.CoreEngine.Serialization.SectionedBinaryWriter.Section
Sections can contain either subsections or fragments. Nested sections form a tree.
Parcel.CoreEngine.Serialization.SectionedBinaryWriter.Fragment
A record of each write operation, capturing the type written and the size (in bytes).
Parcel.CoreEngine.Serialization.SectionedBinaryWriter._buffer
Temporary buffer while we gather all the data and information about the file structure.
Parcel.CoreEngine.Serialization.SectionedBinaryWriter._bufferWriter
An internal BinaryWriter writing to our buffer.
Parcel.CoreEngine.Serialization.SectionedBinaryWriter._underlying
The actual "target" stream that we will eventually write to, while appending a description of the file structure.
Parcel.CoreEngine.Serialization.SectionedBinaryWriter._root
The root section (if there is one) or first top-level section created.
Parcel.CoreEngine.Serialization.SectionedBinaryWriter._current
The currently active section (top of the stack).
Parcel.CoreEngine.Serialization.SectionedBinaryWriter._sectionsStack
A stack to track the nesting of sections.
Parcel.CoreEngine.Serialization.SectionedBinaryWriter.GenerateFileFormatDocumentation
Print to human-readable tree structure
Parcel.CoreEngine.Serialization.SectionedBinaryWriter.Write7BitEncodedInt()
We also override the 7-bit encoded int method for completeness.
Parcel.CoreEngine.Serialization.SectionedBinaryWriter.WriteFileStructure()
Writes a deserializable description of the file structure into the underlying stream
before the actual data buffer.
Parcel.CoreEngine.Serialization.TextSerializer
Remarks
Consider making it similar to Godot tscn format.
Parcel.CoreEngine.Serialization.ZoraParser
A simple CLI parser that parses each line into Node objects. The syntax is MiniParcel like but this parser doesn't handles any execution or node mapping.
Lines can be grouped into sections, which gives a Graph object.
Parcel.CoreEngine.Serialization.ZoraParser.Node.Callable
Remarks
Pending merging with Parcel.NExT.Interpreter.Types.Callable
Parcel.CoreEngine.Serialization.ZoraParser.Node.NextNode
Name of the next node to be executed.
Parcel.CoreEngine.Serialization.ZoraParser.Node.FindCallable()
Remarks
Unlike PV1 Neo, where every ParcelNode is strongly typed already - in the case of ZoraParser or MiniParcel, especially because of the permission of optional arguments, we cannot tell whether a particular node definition matches any Toolbox node simply by comparing strings. We don't have argument type information, and we don't know how many arguments are formally declared on a matching function - we sort of having to search and compare with each available methods (including constructors and properties).
Parcel.CoreEngine.Serialization.Evaluator
Interprets nodes one by one to support sequential execution.
Parcel.CoreEngine.Standardization.UniquelyIdentifiableNaming
Provides unique naming solving for nodes
Parcel.CoreEngine.Standardization.UniquelyIdentifiableNaming.TagUniqueNamesInSelfContainedNodes()
Remarks
Current implementation cares not node target type and only concerns the explicit names.
Parcel.CoreEngine.Types.ProceduralContextConnection
An empty type representing procedural context.
Parcel.CoreEngine.Types.AbstractObject
A base type for procedural context
Remarks
TODO: Why do we need so many explicitly named variables - sounds like we could just use function overload? Or is it better to be semantically explicit for Divooka GUI.
Remark: Right now the variable setting methods are public so it's possible (e.g. in the future) to set variables of other objects in this fashion.
Parcel.CoreEngine.Types.AbstractObject.Variables
Backing store for all variables.
Parcel.CoreEngine.Types.AbstractObject.SetObjectVariable()
Sets a variable to an arbitrary object instance.
Parameters
| Name | Description | Default |
|---|---|---|
name |
Name/key for the stored object. | |
value |
Object to store. |
Returns
The same object value.
Parcel.CoreEngine.Types.AbstractObject.GetObjectVariable()
Reads a variable as an arbitrary object.
Parameters
| Name | Description | Default |
|---|---|---|
name |
Name/key for the stored object. |
Returns
The stored object, or throws if missing or not found.
Parcel.CoreEngine.Types.AbstractObject.GetVariableAs``1()
A more generic way to retrieve a variable with a known type T.
Throws an exception if type mismatch or key is not found.
Parcel.CoreEngine.Types.AbstractObject.LastReturn
Remarks
TODO: Might also want to do a (dynamic) "Break Return" node to break arrays or tuples, like Break nodes in Unreal Engine for structs.
It can be so smart that: 1) It supports manual break, 2) It supports automatic break based on whether input value is array[], ValueTuple, or regular objects.
Parcel.CoreEngine.Types.Subprogram
A base class for a Divooka graph to be exposed as Subprogram.
Requires a custom event named `Entry`.
Parcel.CoreEngine.Types.ProceduralContextBaseTypeApplication
A base class for a Divooka program entry.
Parcel.CoreEngine.Types.ProceduralContextBaseTypeApplication.Start
Divooka procedural program entry, equivalanet to "Main" in many programming language.
Parcel.CoreEngine.Types.ProceduralContextBaseTypeApplication.HostBoundPreviewObject
Host environment need to explicitly bind to this. This is an exclusive resource per host environment.
Notice since the current owner of this can run long, the subscriber must explicitly unsubscribe to prevent memory leak, for this event may not be be GC collected when the subscriber goes out of scope.
Also generally only the top-level host object should generally touch this.
Parcel.CoreEngine.Types.ProceduralContextBaseTypeApplication.GUIPreviewObject()
Requests the host environment to "preview" an object. This may be in the form of console output (for console host), windowed output, or any other form (e.g. in Terrain Generator this can be the 3D preview panel).
The preview output may be monolithic (as in terrrain editor), or have a multitude.
Parameters
| Name | Description | Default |
|---|---|---|
object |
The value to preview | |
windowWidth |
Suggested window width. -1 for default. | |
windowHeight |
Suggested window height, -1 for default. |
Parcel.CoreEngine.Versioning.EngineVersion
This is the only version across the entire Parcel.NExT implementations and considers changes to all components including (canonical) front-end and back-end; (This version number may exclude certain front-ends)
The version number should match release number on Github, and match the csproj build version
Parcel.CoreEngine.Versioning.EngineVersion.Changelog
Format: version, key summary, component highlights, timeline.
Parcel.CoreEngine.YAMLDSL.Ruth
A Text-based serializer/deserializer implementing a YAML based DSL.
This is not intended for whole document serialization.
Remarks
As of 2024-09-05, while MiniParcel and proper graph editor is still WIP and DiOS and PSL is still WIP, it's useful to have some form of authorization medium in YAML as DSL for experimentations.
In the future will likely merge this with TextSerializer.
(2024-09-13) Can we please have a RFC before implementing this? I don't see the value/need of this at all. E.g. Why can't we just do a simple Roslyn based Pure script as serialization? What exactly is it that either MiniParcel or YamlDSL achieves that we couldn't achieve with Pure already? (Answer) Pure/Lua executes things, but we wish to just deserialize without executing anything, aka. get a Zora document object with node definitions, so we can analyze things instead of/before executing anything. What's more, "decorative" details like decorators (node attributes) are not a concept available in traditional procedural programming languages and must be more reliably represented in YAML or similar declarative formats.
(2024-09-19) For the purpose of node graph and node graph only - everything can be represented as nodes, but in the future when we have multimedia data (image, 3D mesh), things are more efficiently represented using dedicated serialization formats (even if they can always be converted to strings) for clean handling.
(2024-09-19) For maximum portability and to avoid assembly dependencies, we didn't use YAMLDotNet and implemented specific (de)serialization routines.
Parcel.CoreEngine.YAMLDSL.Ruth.AbstractNode
A node can represent any type of data: node itself, graphs, document metadata, etc.
Parcel.CoreEngine.YAMLDSL.Ruth.AbstractNode.Target
Format: "ClassName.MethodName"
Or some system node target names.
Parcel.CoreEngine.YAMLDSL.Ruth.AbstractDecorator.FindType()
Find a type with a constructor that matches the keys and values of Attributes
Parcel.Neo.Base.Serialization.GraphMode
Graph mode or execution paradigm.
Parcel.Neo.Base.Serialization.GraphMode.Dataflow
Dataflow or functional context, with minimal states.
Parcel.Neo.Base.Serialization.GraphMode.Procedural
Procedural context, with lots of states.
Parcel.Neo.Base.Serialization.PV1NeoDocument
A representation of serialized document
Parcel.Neo.Base.Serialization.PV1NeoDocument.RuntimeMetadata.FileFormatVersion
Remarks
Historical versions:
1.0: Only single graph document, where runtime metadata and document metadata is contained within Graph construct itself. Graph doesn't have GraphMetadata information.
PV1Neo 1.1: Single document, multiple graphs; Graphs have GraphMetadata information.
Parcel.Neo.Base.Serialization.PV1NeoDocument.GraphMetadata.ProceduralContextType
An identifier of the procedural context type; Only valid when Parcel.Neo.Base.Serialization.PV1NeoDocument.GraphMetadata.GraphMode is Parcel.Neo.Base.Serialization.GraphMode.Procedural.
Parcel.Neo.Base.Serialization.PV1NeoDocument.NodeData.NodeType
Full name of corresponding type
Parcel.Neo.Base.Serialization.PV1NeoDocument.ConnectionData
Remarks
Remark-cz: Notice the concept of connection/connector is redundant and totally unnecessary and complicates handling; This is areminicent of PV1 Neo and Nodify framework, we will optimize it away soon
Parcel.Neo.Base.Serialization.PV1NeoDocument.LegacyFileVersion1VersionString
Use between 2024 July-Aug
Parcel.Neo.Base.Serialization.PV1NeoDocument.LegacyFileVersion2VersionString
Use between 2024 Aug-onward
Divooka.Core.Primitives.RawDataGrid
A plain CSV-intermediate transfer format for communicating 2D data grid between different runtimes and between backend and front-end
Divooka.Core.Primitives.RawDataGrid.#ctor()
A plain CSV-intermediate transfer format for communicating 2D data grid between different runtimes and between backend and front-end
Divooka.Platform.Types.DictionaryRoutines
Zora language level support for dictionary creation and manipulation (with simplifications), encapsulated as node-friendly routines
Divooka.Platform.Types.DictionaryRoutines.MakeDictionary()
Defines a dictionary mapping of keys to values.
Remarks
This particular node can be overridden in the front-end to provide richer interactivities