finos/morphir-scala / .claude/skills/squire
squire
VerifiedUse when morphir-scala work needs environment diagnostics or build/network/sandbox unblocking; reference repository management; branch lifecycle refresh after squash-merging a target branch into main; Morphir IR spec/schema sync or export; or task-tracking configuration and beads mode resolution.
test-resources/schemas/morphir-ir-v4.json
View on GitHub{
"$schema": "http://json-schema.org/draft-07/schema#",
"$id": "https://morphir.finos.org/schemas/morphir-ir-v4.json",
"title": "Morphir IR Distribution",
"description": "Morphir IR format version 4.\n\nV4 introduces key improvements:\n- Wrapper object format for distributions (replaces tagged arrays)\n- Object/dict format for modules, types, values, and dependencies\n- Explicit TypeAttributes and ValueAttributes\n- Canonical string formats for names, paths, and FQNames\n- Embedded documentation support\n- New value expressions (Hole, Native, External)\n\nSee the complete example at: docs/spec/ir/schemas/v4/complete-example.json\n",
"type": "object",
"required": [
"formatVersion",
"distribution"
],
"properties": {
"formatVersion": {
"oneOf": [
{
"type": "string",
"pattern": "^4\\.0\\.0(-[a-zA-Z0-9.-]+)?(\\+[a-zA-Z0-9.-]+)?$",
"description": "Semantic version string (e.g., '4.0.0', '4.0.0-alpha.1')",
"examples": [
"4.0.0",
"4.0.0-alpha.1",
"4.0.0+20240123"
]
},
{
"type": "integer",
"minimum": 4,
"description": "Legacy integer format for backwards compatibility",
"examples": [
4
]
}
]
},
"distribution": {
"oneOf": [
{
"$ref": "#/definitions/LibraryDistribution"
},
{
"$ref": "#/definitions/SpecsDistribution"
},
{
"$ref": "#/definitions/ApplicationDistribution"
}
],
"description": "Root distribution node. V4 uses wrapper object format where the distribution type\nis the key and its content is the value.\n\nExample: { \"Library\": { \"packageName\": \"...\", \"dependencies\": {...}, \"def\": {...} } }\n"
}
},
"definitions": {
"NameString": {
"type": "string",
"pattern": "^([a-z0-9]+|\\([a-z0-9]+\\))(-([a-z0-9]+|\\([a-z0-9]+\\)))*$",
"description": "Canonical string representation of a name.\nSupports kebab-case with parenthesized acronyms (e.g., \"(usd)\", \"my-(api)-client\").\n",
"examples": [
"my-name",
"user-id",
"value-in-(usd)",
"price-per-(unit)"
]
},
"Name": {
"oneOf": [
{
"$ref": "#/definitions/NameString"
},
{
"type": "array",
"items": {
"type": "string",
"pattern": "^[a-z][a-z0-9]*$"
},
"minItems": 1,
"description": "Legacy array representation (e.g., [\"my\", \"name\"] for 'my-name')",
"examples": [
[
"my",
"name"
],
[
"user",
"id"
]
]
}
]
},
"PathString": {
"type": "string",
"pattern": "^([a-z0-9]+|\\([a-z0-9]+\\))(-([a-z0-9]+|\\([a-z0-9]+\\)))*(/([a-z0-9]+|\\([a-z0-9]+\\))(-([a-z0-9]+|\\([a-z0-9]+\\)))*)*$",
"description": "Canonical string representation of a path (package or module path).\nSegments are Names joined by forward slashes.\n",
"examples": [
"morphir/sdk",
"my-org/domain/users",
"u-s/f-r-2052-a/data-tables"
]
},
"Path": {
"oneOf": [
{
"$ref": "#/definitions/PathString"
},
{
"type": "array",
"items": {
"$ref": "#/definitions/Name"
},
"minItems": 1,
"description": "Legacy array representation (e.g., [[\"morphir\"], [\"sdk\"]] for 'morphir/sdk')",
"examples": [
[
[
"morphir"
],
[
"sdk"
]
],
[
[
"my-org"
],
[
"domain"
],
[
"users"
]
]
]
}
]
},
"PackageName": {
"$ref": "#/definitions/Path",
"description": "Package identifier. Examples: \"morphir/sdk\", \"my-org/my-project\"\n",
"examples": [
"morphir/sdk",
"my-org/my-project",
"regulation"
]
},
"ModuleName": {
"$ref": "#/definitions/Path",
"description": "Module path within a package. Examples: \"basics\", \"list\", \"domain/users\"\n",
"examples": [
"basics",
"list",
"domain/users",
"u-s/f-r-2052-a/data-tables"
]
},
"FQNameString": {
"type": "string",
"pattern": "^([a-z0-9]+|\\([a-z0-9]+\\))(-([a-z0-9]+|\\([a-z0-9]+\\)))*(/([a-z0-9]+|\\([a-z0-9]+\\))(-([a-z0-9]+|\\([a-z0-9]+\\)))*)*:([a-z0-9]+|\\([a-z0-9]+\\))(-([a-z0-9]+|\\([a-z0-9]+\\)))*(/([a-z0-9]+|\\([a-z0-9]+\\))(-([a-z0-9]+|\\([a-z0-9]+\\)))*)*#([a-z0-9]+|\\([a-z0-9]+\\))(-([a-z0-9]+|\\([a-z0-9]+\\)))*$",
"description": "Fully-qualified name in canonical string format: \"package:module#name\"\nThis uniquely identifies a type or value across the entire IR.\n",
"examples": [
"morphir/sdk:list#map",
"morphir/sdk:basics#int",
"my-org/domain:users#create-user"
]
},
"FQName": {
"oneOf": [
{
"$ref": "#/definitions/FQNameString"
},
{
"type": "array",
"minItems": 3,
"maxItems": 3,
"items": [
{
"$ref": "#/definitions/PackageName"
},
{
"$ref": "#/definitions/ModuleName"
},
{
"$ref": "#/definitions/Name"
}
],
"description": "Legacy array representation: [packageName, moduleName, name]",
"examples": [
[
"morphir/sdk",
"list",
"map"
],
[
[
"morphir"
],
[
"sdk"
],
[
"list"
],
[
"map"
]
]
]
}
]
},
"SourceLocation": {
"type": "object",
"required": [
"startLine",
"startColumn",
"endLine",
"endColumn"
],
"properties": {
"startLine": {
"type": "integer",
"description": "Starting line number (1-based)"
},
"startColumn": {
"type": "integer",
"description": "Starting column number (1-based)"
},
"endLine": {
"type": "integer",
"description": "Ending line number (1-based)"
},
"endColumn": {
"type": "integer",
"description": "Ending column number (1-based)"
}
},
"description": "Source code location for error reporting and IDE support",
"examples": [
{
"startLine": 10,
"startColumn": 5,
"endLine": 10,
"endColumn": 15
},
{
"startLine": 42,
"startColumn": 1,
"endLine": 45,
"endColumn": 20
}
]
},
"TypeAttributes": {
"type": "object",
"properties": {
"source": {
"$ref": "#/definitions/SourceLocation"
},
"constraints": {
"type": "object",
"description": "Type constraints (placeholder for future expansion)"
},
"extensions": {
"type": "object",
"description": "Custom extension data"
}
},
"description": "V4 explicit type attributes replacing generic 'a' parameter.\nContains source location, type constraints, and extensibility hooks.\n",
"examples": [
{},
{
"source": {
"startLine": 10,
"startColumn": 5,
"endLine": 10,
"endColumn": 15
}
},
{
"source": {
"startLine": 10,
"startColumn": 5,
"endLine": 10,
"endColumn": 15
},
"extensions": {
"custom": "data"
}
}
]
},
"ValueAttributes": {
"type": "object",
"properties": {
"source": {
"$ref": "#/definitions/SourceLocation"
},
"inferredType": {
"$ref": "#/definitions/Type",
"description": "Type inferred during type checking"
},
"extensions": {
"type": "object",
"description": "Custom extension data"
}
},
"description": "V4 explicit value attributes replacing generic 'a' parameter.\nContains source location, inferred type, and extensibility hooks.\n",
"examples": [
{},
{
"source": {
"startLine": 20,
"startColumn": 1,
"endLine": 20,
"endColumn": 10
}
},
{
"source": {
"startLine": 20,
"startColumn": 1,
"endLine": 20,
"endColumn": 10
},
"inferredType": "morphir/sdk:basics#int"
}
]
},
"Annotation": {
"oneOf": [
{
"type": "string",
"pattern": "^[a-z0-9-()/]+:[a-z0-9-()/]+#[a-z0-9-()]+(:.+)?$",
"description": "Compact shorthand format for an annotation: \"fqname\" or \"fqname:value\".\nExamples:\n- \"morphir/sdk:annotations#stable\"\n- \"my-org/sdk:annotations#deprecated:Use new-version instead\"\n"
},
{
"type": "object",
"required": [
"name"
],
"properties": {
"name": {
"$ref": "#/definitions/FQName"
},
"arguments": {
"type": "array",
"items": {
"$ref": "#/definitions/AnnotationArgument"
},
"description": "Arguments to the annotation (positional or named)"
}
}
}
],
"description": "Structured annotation on a specification type.\nCan be a compact string or a canonical object.\n",
"examples": [
"morphir/sdk:annotations#stable",
"my-org/sdk:annotations#deprecated:Use new-version instead",
{
"name": "morphir/sdk:annotations#deprecated",
"arguments": [
{
"Literal": {
"StringLiteral": "Use new-version instead"
}
}
]
}
]
},
"AnnotationArgument": {
"oneOf": [
{
"$ref": "#/definitions/Value",
"description": "Positional argument"
},
{
"type": "object",
"required": [
"name",
"value"
],
"properties": {
"name": {
"$ref": "#/definitions/Name"
},
"value": {
"$ref": "#/definitions/Value"
}
},
"description": "Named argument"
}
],
"description": "An argument to an annotation, either positional (Value) or named."
},
"Access": {
"type": "string",
"enum": [
"Public",
"Private",
"public",
"private",
"pub"
],
"description": "Visibility level for definitions.\nCanonical: \"Public\" or \"Private\"\nAccepted: lowercase (\"public\", \"private\") and abbreviation (\"pub\" for Public)\n\nEncoders should output the canonical form.\n",
"examples": [
"Public",
"Private",
"pub"
]
},
"AccessControlled": {
"oneOf": [
{
"type": "object",
"oneOf": [
{
"required": [
"Public"
],
"additionalProperties": false,
"properties": {
"Public": {}
}
},
{
"required": [
"Private"
],
"additionalProperties": false,
"properties": {
"Private": {}
}
},
{
"required": [
"public"
],
"additionalProperties": false,
"properties": {
"public": {}
}
},
{
"required": [
"private"
],
"additionalProperties": false,
"properties": {
"private": {}
}
},
{
"required": [
"pub"
],
"additionalProperties": false,
"properties": {
"pub": {}
}
}
]
},
{
"type": "object",
"required": [
"access",
"value"
],
"properties": {
"access": {
"$ref": "#/definitions/Access"
},
"value": {}
}
}
],
"description": "Wrapper for access control.\n\nCanonical: Access level as the key: { \"Public\": {...} } or { \"Private\": {...} }\nAccepted: lowercase and abbreviations: { \"pub\": {...} }, { \"public\": {...} }, { \"private\": {...} }\nLegacy: { \"access\": \"Public\", \"value\": {...} }\n\nEncoders should output the canonical form.\n",
"examples": [
{
"Public": {
"some": "data"
}
},
{
"Private": {
"internal": "data"
}
},
{
"pub": {
"some": "data"
}
},
{
"access": "Public",
"value": {
"some": "data"
}
}
]
},
"Dependencies": {
"type": "object",
"additionalProperties": {
"$ref": "#/definitions/PackageSpecification"
},
"description": "Dictionary mapping package names to their specifications.\nV4 uses object format: { \"package/name\": { \"modules\": {...} } }\n",
"examples": [
{
"morphir/sdk": {
"modules": {
"basics": {
"types": {},
"values": {}
}
}
}
},
{
"morphir/sdk": {
"modules": {
"basics": {
"types": {},
"values": {}
}
}
},
"other/pkg": {
"modules": {}
}
}
]
},
"PackageDefinition": {
"type": "object",
"properties": {
"modules": {
"type": "object",
"additionalProperties": {
"allOf": [
{
"$ref": "#/definitions/AccessControlled"
},
{
"properties": {
"value": {
"$ref": "#/definitions/ModuleDefinition"
}
}
}
]
},
"description": "Dictionary mapping module paths to access-controlled module definitions.\nV4 uses object format: { \"module/path\": { \"access\": \"Public\", \"value\": {...} } }\nOptional - defaults to empty object if omitted.\n"
}
},
"description": "Full package definition containing all modules with their complete implementations.\nUsed in Library and Application distributions. The \"modules\" field can be omitted\nif empty.\n",
"examples": [
{
"modules": {
"domain/users": {
"access": "Public",
"value": {
"types": {},
"values": {}
}
}
}
},
{}
]
},
"PackageSpecification": {
"type": "object",
"properties": {
"modules": {
"type": "object",
"additionalProperties": {
"$ref": "#/definitions/ModuleSpecification"
},
"description": "Dictionary mapping module paths to module specifications.\nV4 uses object format: { \"module/path\": { \"types\": {...}, \"values\": {...} } }\nOptional - defaults to empty object if omitted.\n"
}
},
"description": "Package specification containing only public interfaces (no implementations).\nUsed in dependencies and Specs distributions. The \"modules\" field can be omitted\nif empty.\n",
"examples": [
{
"modules": {
"basics": {
"types": {
"int": {
"OpaqueTypeSpecification": {}
}
},
"values": {}
}
}
},
{}
]
},
"LibraryDistribution": {
"type": "object",
"required": [
"Library"
],
"additionalProperties": false,
"properties": {
"Library": {
"type": "object",
"required": [
"packageName"
],
"properties": {
"packageName": {
"$ref": "#/definitions/PackageName"
},
"dependencies": {
"$ref": "#/definitions/Dependencies"
},
"def": {
"$ref": "#/definitions/PackageDefinition"
}
}
}
},
"description": "Library distribution - a reusable package with full implementations.\nUsed for libraries that can be imported by other packages.\nThe \"dependencies\" and \"def\" fields can be omitted if empty.\n",
"examples": [
{
"Library": {
"packageName": "my-org/my-lib",
"dependencies": {},
"def": {
"modules": {}
}
}
},
{
"Library": {
"packageName": "my-org/my-lib",
"def": {}
}
},
{
"Library": {
"packageName": "my-org/my-lib"
}
}
]
},
"SpecsDistribution": {
"type": "object",
"required": [
"Specs"
],
"additionalProperties": false,
"properties": {
"Specs": {
"type": "object",
"required": [
"packageName"
],
"properties": {
"packageName": {
"$ref": "#/definitions/PackageName"
},
"dependencies": {
"$ref": "#/definitions/Dependencies"
},
"spec": {
"$ref": "#/definitions/PackageSpecification"
}
}
}
},
"description": "Specs distribution - contains only public interfaces/specifications.\nUsed for dependencies or FFI bindings where implementations are not needed.\nThe \"dependencies\" and \"spec\" fields can be omitted if empty.\n",
"examples": [
{
"Specs": {
"packageName": "morphir/sdk",
"dependencies": {},
"spec": {
"modules": {}
}
}
},
{
"Specs": {
"packageName": "morphir/sdk",
"spec": {}
}
},
{
"Specs": {
"packageName": "morphir/sdk"
}
}
]
},
"ApplicationDistribution": {
"type": "object",
"required": [
"Application"
],
"additionalProperties": false,
"properties": {
"Application": {
"type": "object",
"required": [
"packageName",
"entryPoints"
],
"properties": {
"packageName": {
"$ref": "#/definitions/PackageName"
},
"dependencies": {
"$ref": "#/definitions/ApplicationDependencies"
},
"def": {
"$ref": "#/definitions/PackageDefinition"
},
"entryPoints": {
"type": "object",
"additionalProperties": {
"$ref": "#/definitions/EntryPoint"
},
"description": "Map of entry point names (keys) to their definitions.\n\nThe key is an arbitrary identifier chosen by the developer (e.g., \"startup\", \"build\", \"api-handler\").\nThe EntryPoint object contains a \"kind\" field that categorizes it semantically (main, command, handler, job, policy).\n\nExample: An entry point named \"startup\" can have kind \"main\", or \"api-handler\" can have kind \"handler\".\nThe name and kind can differ - the name is for identification, the kind is for semantic categorization.\n"
}
}
}
},
"description": "Application distribution - an executable package with statically linked dependencies.\nContains named entry points that can be invoked by tooling or runtime.\nThe \"dependencies\" and \"def\" fields can be omitted if empty.\n",
"examples": [
{
"Application": {
"packageName": "my-org/my-app",
"dependencies": {},
"def": {
"modules": {}
},
"entryPoints": {
"startup": {
"target": "my-org/my-app:main#run",
"kind": "main"
}
}
}
},
{
"Application": {
"packageName": "my-org/my-app",
"def": {},
"entryPoints": {
"main": {
"target": "my-org/my-app:main#run",
"kind": "main"
}
}
}
},
{
"Application": {
"packageName": "my-org/my-app",
"entryPoints": {
"main": {
"target": "my-org/my-app:main#run",
"kind": "main"
}
}
}
}
]
},
"ApplicationDependencies": {
"type": "object",
"additionalProperties": {
"$ref": "#/definitions/PackageDefinition"
},
"description": "Dictionary mapping package names to full definitions (statically linked for Application distributions).\nUnlike Library dependencies which use specifications, Application dependencies include full implementations\nfor static linking.\n",
"examples": [
{
"morphir/sdk": {
"modules": {
"basics": {
"access": "Public",
"value": {
"types": {},
"values": {}
}
}
}
}
}
]
},
"EntryPoint": {
"type": "object",
"required": [
"target",
"kind"
],
"properties": {
"target": {
"$ref": "#/definitions/FQName",
"description": "Fully-qualified name of the value to invoke"
},
"kind": {
"$ref": "#/definitions/EntryPointKind",
"description": "Semantic category of this entry point. Note: This is distinct from the entry point name (the dictionary key).\nThe name is an arbitrary identifier, while kind is a semantic category from a fixed set.\n"
},
"doc": {
"type": "string",
"description": "Documentation for this entry point"
}
},
"description": "Defines an entry point for an Application distribution.\nThe entry point name (the dictionary key) is arbitrary, while 'kind' provides semantic categorization.\n",
"examples": [
{
"target": "my-org/my-app:main#run",
"kind": "main",
"doc": "Application startup entry point"
},
{
"target": "my-org/my-app:api#handle",
"kind": "handler",
"doc": "HTTP API handler"
}
]
},
"EntryPointKind": {
"type": "string",
"enum": [
"main",
"command",
"handler",
"job",
"policy"
],
"description": "Semantic category for entry points. Used by tooling and runtime to determine behavior.\n\n- \"main\": Default/primary entry point (like application startup)\n- \"command\": CLI subcommand\n- \"handler\": Service endpoint or message handler\n- \"job\": Batch or scheduled job\n- \"policy\": Business policy or rule\n",
"examples": [
"main",
"command",
"handler",
"job",
"policy"
]
},
"ModuleDefinition": {
"type": "object",
"properties": {
"types": {
"type": "object",
"additionalProperties": {
"allOf": [
{
"$ref": "#/definitions/AccessControlled"
},
{
"properties": {
"value": {
"oneOf": [
{
"type": "object",
"required": [
"doc",
"value"
],
"properties": {
"doc": {
"type": "string"
},
"value": {
"$ref": "#/definitions/TypeDefinition"
}
}
},
{
"$ref": "#/definitions/TypeDefinition"
}
]
}
}
}
]
},
"description": "Dictionary mapping type names to access-controlled type definitions.\nV4 uses object format: { \"type-name\": { \"access\": \"Public\", \"TypeAliasDefinition\": {...} } }\nDocumentation can be included inline or omitted if None.\nOptional - defaults to empty object if omitted.\n"
},
"values": {
"type": "object",
"additionalProperties": {
"allOf": [
{
"$ref": "#/definitions/AccessControlled"
},
{
"properties": {
"value": {
"oneOf": [
{
"type": "object",
"required": [
"doc",
"value"
],
"properties": {
"doc": {
"type": "string"
},
"value": {
"$ref": "#/definitions/ValueDefinition"
}
}
},
{
"$ref": "#/definitions/ValueDefinition"
}
]
}
}
}
]
},
"description": "Dictionary mapping value names to access-controlled value definitions.\nV4 uses object format: { \"value-name\": { \"access\": \"Public\", \"ExpressionBody\": {...} } }\nDocumentation can be included inline or omitted if None.\nOptional - defaults to empty object if omitted.\n"
},
"doc": {
"type": "string",
"description": "Optional module-level documentation"
}
},
"description": "Full module definition containing all types and values with their implementations.\nIncludes both public and private items. Used in PackageDefinition.\nThe \"types\" and \"values\" fields can be omitted if empty.\n",
"examples": [
{
"types": {
"user": {
"access": "Public",
"TypeAliasDefinition": {
"typeParams": [],
"typeExp": "morphir/sdk:string#string"
}
}
},
"values": {}
},
{
"types": {},
"values": {
"calculate": {
"access": "Public",
"ExpressionBody": {
"inputTypes": {},
"outputType": "morphir/sdk:basics#int",
"body": {
"Literal": {
"attributes": {},
"literal": {
"IntegerLiteral": 42
}
}
}
}
}
},
"doc": "Module documentation"
},
{
"values": {
"main": {
"access": "Public",
"ExpressionBody": {
"inputTypes": {},
"outputType": {
"Unit": {}
},
"body": {
"Unit": {}
}
}
}
}
}
]
},
"ModuleSpecification": {
"type": "object",
"properties": {
"annotations": {
"type": "array",
"items": {
"$ref": "#/definitions/Annotation"
},
"description": "Module-level annotations"
},
"types": {
"type": "object",
"additionalProperties": {
"oneOf": [
{
"type": "object",
"required": [
"doc",
"value"
],
"properties": {
"doc": {
"type": "string"
},
"value": {
"$ref": "#/definitions/TypeSpecification"
}
}
},
{
"$ref": "#/definitions/TypeSpecification"
}
]
},
"description": "Dictionary mapping type names to documented type specifications.\nV4 uses object format: { \"type-name\": { \"TypeAliasSpecification\": {...} } }\nDocumentation can be included inline or omitted if None.\nOptional - defaults to empty object if omitted.\n"
},
"values": {
"type": "object",
"additionalProperties": {
"oneOf": [
{
"type": "object",
"required": [
"doc",
"value"
],
"properties": {
"doc": {
"type": "string"
},
"value": {
"$ref": "#/definitions/ValueSpecification"
}
}
},
{
"$ref": "#/definitions/ValueSpecification"
}
]
},
"description": "Dictionary mapping value names to documented value specifications.\nV4 uses object format: { \"value-name\": { \"inputs\": {...}, \"output\": \"...\" } }\nDocumentation can be included inline or omitted if None.\nOptional - defaults to empty object if omitted.\n"
},
"doc": {
"type": "string",
"description": "Optional module-level documentation"
}
},
"description": "Module specification containing only public interfaces (no implementations).\nUsed in PackageSpecification and dependencies.\nThe \"types\" and \"values\" fields can be omitted if empty.\n",
"examples": [
{
"types": {
"int": {
"OpaqueTypeSpecification": {}
}
},
"values": {
"add": {
"inputs": {
"a": "morphir/sdk:basics#int",
"b": "morphir/sdk:basics#int"
},
"output": "morphir/sdk:basics#int"
}
}
},
{
"types": {
"int": {
"OpaqueTypeSpecification": {}
}
}
}
]
},
"Type": {
"oneOf": [
{
"$ref": "#/definitions/VariableType"
},
{
"$ref": "#/definitions/ReferenceType"
},
{
"$ref": "#/definitions/TupleType"
},
{
"$ref": "#/definitions/RecordType"
},
{
"$ref": "#/definitions/ExtensibleRecordType"
},
{
"$ref": "#/definitions/FunctionType"
},
{
"$ref": "#/definitions/UnitType"
}
]
},
"VariableType": {
"type": "string",
"pattern": "^[a-z][a-z0-9]*(-[a-z0-9]+)*$",
"description": "Type variable (generic type parameter).\nV4 compact format: bare name string (no ':' or '#').\nDistinguished from Reference by absence of FQName separators.\n",
"examples": [
"a",
"comparable",
"number"
]
},
"ReferenceType": {
"oneOf": [
{
"type": "string",
"pattern": "^[a-z0-9-()/]+:[a-z0-9-()/]+#[a-z0-9-()]+$",
"description": "Compact format for Reference without type arguments.\nJust the FQName string: \"package:module#name\"\n"
},
{
"type": "object",
"required": [
"Reference"
],
"additionalProperties": false,
"properties": {
"Reference": {
"type": "string",
"pattern": "^[a-z0-9-()/]+:[a-z0-9-()/]+#[a-z0-9-()]+$"
}
},
"description": "Wrapper format for Reference without type arguments.\n"
},
{
"type": "object",
"required": [
"Reference"
],
"additionalProperties": false,
"properties": {
"Reference": {
"type": "array",
"minItems": 2,
"items": [
{
"$ref": "#/definitions/FQName"
}
],
"additionalItems": {
"$ref": "#/definitions/Type"
},
"description": "Array where first element is FQName, rest are type arguments.\n"
}
},
"description": "Canonical format for Reference with type arguments.\n"
},
{
"type": "object",
"required": [
"Reference"
],
"additionalProperties": false,
"properties": {
"Reference": {
"type": "object",
"required": [
"fqname"
],
"properties": {
"fqname": {
"$ref": "#/definitions/FQName"
},
"args": {
"type": "array",
"items": {
"$ref": "#/definitions/Type"
}
}
},
"description": "Object with fqname and optional args fields.\n"
}
},
"description": "Expanded wrapper format with explicit fqname and args fields.\n"
}
],
"description": "Reference to a named type, optionally with type arguments.\n\nCanonical (no args): \"morphir/sdk:basics#int\"\nCanonical (with args): {\"Reference\": [\"morphir/sdk:list#list\", \"a\"]}\n\nAccepted formats:\n- Bare FQName string: \"morphir/sdk:basics#int\"\n- Wrapper with FQName: {\"Reference\": \"morphir/sdk:basics#int\"}\n- Wrapper with array: {\"Reference\": [\"morphir/sdk:list#list\", \"a\"]}\n- Wrapper with object: {\"Reference\": {\"fqname\": \"morphir/sdk:list#list\", \"args\": [\"a\"]}}\n\nEncoders should output canonical form.\n",
"examples": [
"morphir/sdk:basics#int",
"morphir/sdk:string#string",
{
"Reference": "morphir/sdk:basics#int"
},
{
"Reference": [
"morphir/sdk:list#list",
"a"
]
},
{
"Reference": [
"morphir/sdk:dict#dict",
"morphir/sdk:string#string",
"morphir/sdk:int#int"
]
},
{
"Reference": {
"fqname": "morphir/sdk:list#list",
"args": [
"a"
]
}
}
]
},
"TupleType": {
"oneOf": [
{
"type": "array",
"items": {
"$ref": "#/definitions/Type"
},
"description": "Bare array of types. Unambiguous because ReferenceType does not accept bare arrays.\n"
},
{
"type": "object",
"required": [
"Tuple"
],
"additionalProperties": false,
"properties": {
"Tuple": {
"type": "array",
"items": {
"$ref": "#/definitions/Type"
}
}
},
"description": "Canonical wrapper format with array of types.\n"
},
{
"type": "object",
"required": [
"Tuple"
],
"additionalProperties": false,
"properties": {
"Tuple": {
"type": "object",
"required": [
"elements"
],
"properties": {
"elements": {
"type": "array",
"items": {
"$ref": "#/definitions/Type"
}
}
}
}
},
"description": "Expanded wrapper format with explicit elements field.\n"
}
],
"description": "Tuple type with multiple element types.\n\nCanonical: {\"Tuple\": [type1, type2, ...]}\n\nAccepted formats:\n- Bare array: [type1, type2, ...] (unambiguous since Reference doesn't use bare arrays)\n- Wrapper with array: {\"Tuple\": [type1, type2, ...]}\n- Wrapper with object: {\"Tuple\": {\"elements\": [type1, type2, ...]}}\n\nEncoders should output canonical form.\n",
"examples": [
[
"morphir/sdk:int#int",
"morphir/sdk:string#string"
],
{
"Tuple": [
"morphir/sdk:int#int",
"morphir/sdk:string#string"
]
},
{
"Tuple": {
"elements": [
"morphir/sdk:int#int",
"morphir/sdk:string#string"
]
}
},
[
"a",
"b",
"c"
]
]
},
"RecordType": {
"type": "object",
"required": [
"Record"
],
"properties": {
"Record": {
"type": "object",
"additionalProperties": {
"$ref": "#/definitions/Type"
},
"description": "Dictionary mapping field names to their types.\nField names use kebab-case.\n"
}
},
"description": "Record type with named fields.\nFormat: {\"Record\": {\"field-name\": type, ...}}\n",
"examples": [
{
"Record": {
"name": "morphir/sdk:string#string",
"age": "morphir/sdk:int#int"
}
},
{
"Record": {
"inflows": "regulation:data-tables#inflows",
"outflows": "regulation:data-tables#outflows"
}
}
]
},
"ExtensibleRecordType": {
"type": "object",
"required": [
"ExtensibleRecord"
],
"properties": {
"ExtensibleRecord": {
"type": "object",
"required": [
"variable",
"fields"
],
"properties": {
"variable": {
"$ref": "#/definitions/Name"
},
"fields": {
"type": "object",
"additionalProperties": {
"$ref": "#/definitions/Type"
}
}
}
}
},
"description": "Extensible record type (row polymorphism).\nFormat: {\"ExtensibleRecord\": {\"variable\": \"a\", \"fields\": {...}}}\n",
"examples": [
{
"ExtensibleRecord": {
"variable": "a",
"fields": {
"name": "morphir/sdk:string#string"
}
}
},
{
"ExtensibleRecord": {
"variable": "r",
"fields": {
"email": "morphir/sdk:string#string"
}
}
}
]
},
"FunctionType": {
"type": "object",
"required": [
"Function"
],
"properties": {
"Function": {
"type": "object",
"required": [
"argumentType",
"returnType"
],
"properties": {
"argumentType": {
"$ref": "#/definitions/Type"
},
"returnType": {
"$ref": "#/definitions/Type"
}
}
}
},
"description": "Function type.\nFormat: {\"Function\": {\"argumentType\": ..., \"returnType\": ...}}\n",
"examples": [
{
"Function": {
"argumentType": "morphir/sdk:int#int",
"returnType": "morphir/sdk:string#string"
}
}
]
},
"UnitType": {
"type": "object",
"required": [
"Unit"
],
"properties": {
"Unit": {
"type": "object"
}
},
"description": "Unit type (the type with exactly one value).\nFormat: {\"Unit\": {}}\n",
"examples": [
{
"Unit": {}
}
]
},
"Field": {
"type": "object",
"required": [
"name",
"tpe"
],
"properties": {
"name": {
"$ref": "#/definitions/Name"
},
"tpe": {
"$ref": "#/definitions/Type"
}
}
},
"TypeSpecification": {
"oneOf": [
{
"$ref": "#/definitions/TypeAliasSpecification"
},
{
"$ref": "#/definitions/OpaqueTypeSpecification"
},
{
"$ref": "#/definitions/CustomTypeSpecification"
},
{
"$ref": "#/definitions/DerivedTypeSpecification"
}
]
},
"TypeAliasSpecification": {
"oneOf": [
{
"type": "object",
"required": [
"TypeAliasSpecification"
],
"additionalProperties": false,
"properties": {
"TypeAliasSpecification": {
"type": "object",
"required": [
"typeParams",
"typeExp"
],
"properties": {
"annotations": {
"type": "array",
"items": {
"$ref": "#/definitions/Annotation"
}
},
"typeParams": {
"type": "array",
"items": {
"$ref": "#/definitions/Name"
}
},
"typeExp": {
"$ref": "#/definitions/Type"
}
}
}
}
},
{
"type": "array",
"items": [
{
"const": "TypeAliasSpecification"
},
{
"type": "array",
"items": {
"$ref": "#/definitions/Name"
}
},
{
"$ref": "#/definitions/Type"
}
]
}
],
"description": "Type alias specification (public interface).\nV4 format: { \"TypeAliasSpecification\": { \"typeParams\": [...], \"typeExp\": ... } }\nLegacy format: [\"TypeAliasSpecification\", [...], ...]\n",
"examples": [
{
"TypeAliasSpecification": {
"typeParams": [],
"typeExp": "morphir/sdk:string#string"
}
},
{
"TypeAliasSpecification": {
"typeParams": [
"a"
],
"typeExp": {
"Reference": [
"morphir/sdk:list#list",
"a"
]
}
}
}
]
},
"OpaqueTypeSpecification": {
"oneOf": [
{
"type": "object",
"required": [
"OpaqueTypeSpecification"
],
"additionalProperties": false,
"properties": {
"OpaqueTypeSpecification": {
"oneOf": [
{
"type": "object",
"properties": {
"annotations": {
"type": "array",
"items": {
"$ref": "#/definitions/Annotation"
}
},
"typeParams": {
"type": "array",
"items": {
"$ref": "#/definitions/Name"
}
}
}
},
{
"type": "object",
"additionalProperties": false,
"properties": {
"annotations": {
"type": "array",
"items": {
"$ref": "#/definitions/Annotation"
}
}
}
}
]
}
}
},
{
"type": "array",
"items": [
{
"const": "OpaqueTypeSpecification"
},
{
"type": "array",
"items": {
"$ref": "#/definitions/Name"
}
}
]
}
],
"description": "Opaque type specification (no visible structure).\nV4 format: { \"OpaqueTypeSpecification\": {} } or { \"OpaqueTypeSpecification\": { \"typeParams\": [...] } }\nLegacy format: [\"OpaqueTypeSpecification\", [...]]\n",
"examples": [
{
"OpaqueTypeSpecification": {}
},
{
"OpaqueTypeSpecification": {
"typeParams": [
"a"
]
}
}
]
},
"CustomTypeSpecification": {
"oneOf": [
{
"type": "object",
"required": [
"CustomTypeSpecification"
],
"additionalProperties": false,
"properties": {
"CustomTypeSpecification": {
"type": "object",
"required": [
"typeParams",
"constructors"
],
"properties": {
"annotations": {
"type": "array",
"items": {
"$ref": "#/definitions/Annotation"
}
},
"typeParams": {
"type": "array",
"items": {
"$ref": "#/definitions/Name"
}
},
"constructors": {
"$ref": "#/definitions/Constructors"
}
}
}
}
},
{
"type": "array",
"items": [
{
"const": "CustomTypeSpecification"
},
{
"type": "array",
"items": {
"$ref": "#/definitions/Name"
}
},
{
"$ref": "#/definitions/Constructors"
}
]
}
],
"description": "Custom type specification (sum type with constructors).\nV4 format: { \"CustomTypeSpecification\": { \"typeParams\": [...], \"constructors\": {...} } }\nLegacy format: [\"CustomTypeSpecification\", [...], [...]]\n",
"examples": [
{
"CustomTypeSpecification": {
"typeParams": [
"a"
],
"constructors": {
"just": [
[
"value",
"a"
]
],
"nothing": []
}
}
}
]
},
"DerivedTypeSpecification": {
"oneOf": [
{
"type": "object",
"required": [
"DerivedTypeSpecification"
],
"additionalProperties": false,
"properties": {
"DerivedTypeSpecification": {
"type": "object",
"required": [
"typeParams",
"baseType",
"fromBaseType",
"toBaseType"
],
"properties": {
"annotations": {
"type": "array",
"items": {
"$ref": "#/definitions/Annotation"
}
},
"typeParams": {
"type": "array",
"items": {
"$ref": "#/definitions/Name"
}
},
"baseType": {
"$ref": "#/definitions/Type"
},
"fromBaseType": {
"$ref": "#/definitions/FQName"
},
"toBaseType": {
"$ref": "#/definitions/FQName"
}
}
}
}
},
{
"type": "array",
"items": [
{
"const": "DerivedTypeSpecification"
},
{
"type": "array",
"items": {
"$ref": "#/definitions/Name"
}
},
{
"type": "object",
"required": [
"baseType",
"fromBaseType",
"toBaseType"
],
"properties": {
"baseType": {
"$ref": "#/definitions/Type"
},
"fromBaseType": {
"$ref": "#/definitions/FQName"
},
"toBaseType": {
"$ref": "#/definitions/FQName"
}
}
}
]
}
],
"description": "Derived type specification (opaque with conversion functions).\nV4 format: { \"DerivedTypeSpecification\": { \"typeParams\": [...], \"baseType\": ..., \"fromBaseType\": ..., \"toBaseType\": ... } }\n",
"examples": [
{
"DerivedTypeSpecification": {
"typeParams": [],
"baseType": "morphir/sdk:string#string",
"fromBaseType": "my-org/sdk:local-date#from-string",
"toBaseType": "my-org/sdk:local-date#to-string"
}
}
]
},
"TypeDefinition": {
"oneOf": [
{
"$ref": "#/definitions/TypeAliasDefinition"
},
{
"$ref": "#/definitions/CustomTypeDefinition"
},
{
"$ref": "#/definitions/IncompleteTypeDefinition"
}
]
},
"TypeAliasDefinition": {
"oneOf": [
{
"type": "object",
"required": [
"TypeAliasDefinition"
],
"additionalProperties": false,
"properties": {
"TypeAliasDefinition": {
"type": "object",
"required": [
"typeParams",
"typeExp"
],
"properties": {
"typeParams": {
"type": "array",
"items": {
"$ref": "#/definitions/Name"
}
},
"typeExp": {
"$ref": "#/definitions/Type"
}
}
}
}
},
{
"type": "array",
"items": [
{
"const": "TypeAliasDefinition"
},
{
"type": "array",
"items": {
"$ref": "#/definitions/Name"
}
},
{
"$ref": "#/definitions/Type"
}
]
}
],
"description": "Type alias definition (implementation).\nV4 format: { \"TypeAliasDefinition\": { \"typeParams\": [...], \"typeExp\": ... } }\nLegacy format: [\"TypeAliasDefinition\", [...], ...]\n",
"examples": [
{
"TypeAliasDefinition": {
"typeParams": [],
"typeExp": "morphir/sdk:string#string"
}
},
{
"TypeAliasDefinition": {
"typeParams": [],
"typeExp": {
"Record": {
"name": "morphir/sdk:string#string",
"age": "morphir/sdk:basics#int"
}
}
}
}
]
},
"CustomTypeDefinition": {
"oneOf": [
{
"type": "object",
"required": [
"CustomTypeDefinition"
],
"additionalProperties": false,
"properties": {
"CustomTypeDefinition": {
"type": "object",
"required": [
"typeParams",
"constructors"
],
"properties": {
"typeParams": {
"type": "array",
"items": {
"$ref": "#/definitions/Name"
}
},
"access": {
"enum": [
"Public",
"Private"
],
"description": "Visibility of constructors"
},
"constructors": {
"$ref": "#/definitions/Constructors"
}
}
}
}
},
{
"type": "array",
"items": [
{
"const": "CustomTypeDefinition"
},
{
"type": "array",
"items": {
"$ref": "#/definitions/Name"
}
},
{
"allOf": [
{
"$ref": "#/definitions/AccessControlled"
},
{
"properties": {
"value": {
"$ref": "#/definitions/Constructors"
}
}
}
]
}
]
}
],
"description": "Custom type definition (sum type implementation).\nV4 format: { \"CustomTypeDefinition\": { \"typeParams\": [...], \"access\": \"Public\", \"constructors\": {...} } }\nLegacy format: [\"CustomTypeDefinition\", [...], { \"access\": ..., \"value\": [...] }]\n",
"examples": [
{
"CustomTypeDefinition": {
"typeParams": [
"a"
],
"access": "Public",
"constructors": {
"just": [
[
"value",
"a"
]
],
"nothing": []
}
}
}
]
},
"IncompleteTypeDefinition": {
"type": "object",
"required": [
"IncompleteTypeDefinition"
],
"additionalProperties": false,
"properties": {
"IncompleteTypeDefinition": {
"type": "object",
"required": [
"typeParams",
"incompleteness"
],
"properties": {
"typeParams": {
"type": "array",
"items": {
"$ref": "#/definitions/Name"
}
},
"incompleteness": {
"$ref": "#/definitions/Incompleteness"
},
"partialTypeExp": {
"$ref": "#/definitions/Type"
}
}
}
},
"description": "Incomplete type definition (V4 feature for best-effort support).\nUsed when a type definition cannot be fully resolved.\n",
"examples": [
{
"IncompleteTypeDefinition": {
"typeParams": [],
"incompleteness": {
"Hole": {
"reason": {
"UnresolvedReference": {
"target": "my-org/project:domain#missing-type"
}
}
}
}
}
}
]
},
"Constructors": {
"oneOf": [
{
"type": "object",
"additionalProperties": {
"type": "array",
"items": {
"type": "array",
"minItems": 2,
"maxItems": 2,
"items": [
{
"$ref": "#/definitions/Name"
},
{
"$ref": "#/definitions/Type"
}
]
}
},
"description": "Object mapping constructor names to their argument lists"
},
{
"type": "array",
"items": {
"type": "array",
"items": [
{
"$ref": "#/definitions/Name"
},
{
"type": "array",
"items": {
"type": "array",
"items": [
{
"$ref": "#/definitions/Name"
},
{
"$ref": "#/definitions/Type"
}
]
}
}
]
}
}
],
"description": "Type constructors. V4 uses object format keyed by constructor name.\nV4 format: { \"just\": [[\"value\", \"a\"]], \"nothing\": [] }\nLegacy format: [[\"just\", [[\"value\", \"a\"]]], [\"nothing\", []]]\n",
"examples": [
{
"just": [
[
"value",
"a"
]
],
"nothing": []
},
{
"ok": [
[
"value",
"ok"
]
],
"err": [
[
"error",
"err"
]
]
}
]
},
"Value": {
"oneOf": [
{
"type": "boolean",
"description": "Shorthand for BoolLiteral"
},
{
"type": "number",
"description": "Shorthand for IntegerLiteral or FloatLiteral"
},
{
"type": "string",
"pattern": "^[a-z0-9-()/]+:[a-z0-9-()/]+#[a-z0-9-()]+$",
"description": "Shorthand for Reference (FQName string)"
},
{
"type": "string",
"pattern": "^([a-z0-9]+|\\([a-z0-9]+\\))(-([a-z0-9]+|\\([a-z0-9]+\\)))*$",
"description": "Shorthand for Variable (Name string)"
},
{
"type": "array",
"items": {
"$ref": "#/definitions/Value"
},
"description": "Shorthand for List"
},
{
"$ref": "#/definitions/LiteralValue"
},
{
"$ref": "#/definitions/ConstructorValue"
},
{
"$ref": "#/definitions/TupleValue"
},
{
"$ref": "#/definitions/ListValue"
},
{
"$ref": "#/definitions/RecordValue"
},
{
"$ref": "#/definitions/VariableValue"
},
{
"$ref": "#/definitions/ReferenceValue"
},
{
"$ref": "#/definitions/FieldValue"
},
{
"$ref": "#/definitions/FieldFunctionValue"
},
{
"$ref": "#/definitions/ApplyValue"
},
{
"$ref": "#/definitions/LambdaValue"
},
{
"$ref": "#/definitions/LetDefinitionValue"
},
{
"$ref": "#/definitions/LetRecursionValue"
},
{
"$ref": "#/definitions/DestructureValue"
},
{
"$ref": "#/definitions/IfThenElseValue"
},
{
"$ref": "#/definitions/PatternMatchValue"
},
{
"$ref": "#/definitions/UpdateRecordValue"
},
{
"$ref": "#/definitions/UnitValue"
}
]
},
"LiteralValue": {
"type": "object",
"required": [
"Literal"
],
"properties": {
"Literal": {
"oneOf": [
{
"type": "boolean"
},
{
"type": "number"
},
{
"type": "string"
},
{
"$ref": "#/definitions/Literal"
},
{
"type": "object",
"required": [
"literal"
],
"properties": {
"attributes": {
"$ref": "#/definitions/ValueAttributes"
},
"literal": {
"oneOf": [
{
"type": "boolean"
},
{
"type": "number"
},
{
"type": "string"
},
{
"$ref": "#/definitions/Literal"
}
]
}
}
}
]
}
},
"description": "Literal constant value. Multiple forms accepted (permissive decoding):\n\n- Most compact: { \"Literal\": 42 } (when type is unambiguous from context)\n- Compact with type: { \"Literal\": { \"IntegerLiteral\": 42 } }\n- Expanded with attributes: { \"Literal\": { \"attributes\": {...}, \"literal\": { \"IntegerLiteral\": 42 } } }\n- Expanded with direct value: { \"Literal\": { \"attributes\": {...}, \"literal\": 42 } }\n\nEncoders should prefer the most compact unambiguous form.\n",
"examples": [
{
"Literal": 42
},
{
"Literal": "hello"
},
{
"Literal": {
"IntegerLiteral": 42
}
},
{
"Literal": {
"FloatLiteral": 3.14
}
},
{
"Literal": {
"attributes": {},
"literal": {
"IntegerLiteral": 42
}
}
},
{
"Literal": {
"attributes": {},
"literal": 0
}
}
]
},
"ConstructorValue": {
"type": "object",
"required": [
"Constructor"
],
"properties": {
"Constructor": {
"$ref": "#/definitions/FQName"
}
},
"description": "Reference to a custom type constructor.\nFormat: {\"Constructor\": \"package:module#constructor-name\"}\n",
"examples": [
{
"Constructor": "morphir/sdk:maybe#just"
},
{
"Constructor": "morphir/sdk:maybe#nothing"
}
]
},
"TupleValue": {
"oneOf": [
{
"type": "object",
"required": [
"Tuple"
],
"additionalProperties": false,
"properties": {
"Tuple": {
"type": "array",
"items": {
"$ref": "#/definitions/Value"
}
}
},
"description": "Canonical wrapper format with array of values.\n"
},
{
"type": "object",
"required": [
"Tuple"
],
"additionalProperties": false,
"properties": {
"Tuple": {
"type": "object",
"required": [
"elements"
],
"properties": {
"elements": {
"type": "array",
"items": {
"$ref": "#/definitions/Value"
}
}
}
}
},
"description": "Expanded wrapper format with explicit elements field.\n"
}
],
"description": "Tuple value with multiple elements.\n\nCanonical: {\"Tuple\": [value1, value2, ...]}\n\nAccepted formats:\n- Wrapper with array: {\"Tuple\": [value1, value2, ...]}\n- Wrapper with object: {\"Tuple\": {\"elements\": [value1, value2, ...]}}\n\nNote: Bare arrays are NOT allowed for values (would be ambiguous with ListValue).\n\nEncoders should output canonical form.\n",
"examples": [
{
"Tuple": [
{
"Variable": "x"
},
{
"Literal": {
"IntegerLiteral": 1
}
}
]
},
{
"Tuple": {
"elements": [
{
"Variable": "x"
},
{
"Literal": {
"IntegerLiteral": 1
}
}
]
}
}
]
},
"ListValue": {
"oneOf": [
{
"type": "object",
"required": [
"List"
],
"additionalProperties": false,
"properties": {
"List": {
"type": "array",
"items": {
"$ref": "#/definitions/Value"
}
}
},
"description": "Canonical wrapper format with array of values.\n"
},
{
"type": "object",
"required": [
"List"
],
"additionalProperties": false,
"properties": {
"List": {
"type": "object",
"required": [
"items"
],
"properties": {
"items": {
"type": "array",
"items": {
"$ref": "#/definitions/Value"
}
}
}
}
},
"description": "Expanded wrapper format with explicit items field.\n"
}
],
"description": "List of values.\n\nCanonical: {\"List\": [value1, value2, ...]}\n\nAccepted formats:\n- Wrapper with array: {\"List\": [value1, value2, ...]}\n- Wrapper with object: {\"List\": {\"items\": [value1, value2, ...]}}\n\nNote: Bare arrays are NOT allowed for values (would be ambiguous with TupleValue).\n\nEncoders should output canonical form.\n",
"examples": [
{
"List": [
{
"Literal": {
"IntegerLiteral": 1
}
},
{
"Literal": {
"IntegerLiteral": 2
}
}
]
},
{
"List": {
"items": [
{
"Literal": {
"IntegerLiteral": 1
}
},
{
"Literal": {
"IntegerLiteral": 2
}
}
]
}
}
]
},
"RecordValue": {
"type": "object",
"required": [
"Record"
],
"properties": {
"Record": {
"type": "object",
"additionalProperties": {
"$ref": "#/definitions/Value"
}
}
},
"description": "Record value with named fields.\nFormat: {\"Record\": {\"field-name\": value, ...}}\nField names use kebab-case.\n",
"examples": [
{
"Record": {
"name": {
"Variable": "x"
},
"age": {
"Literal": {
"IntegerLiteral": 25
}
}
}
}
]
},
"VariableValue": {
"type": "object",
"required": [
"Variable"
],
"properties": {
"Variable": {
"$ref": "#/definitions/Name"
}
},
"description": "Reference to a variable in scope.\nFormat: {\"Variable\": \"variable-name\"}\n",
"examples": [
{
"Variable": "x"
},
{
"Variable": "my-value"
}
]
},
"ReferenceValue": {
"type": "object",
"required": [
"Reference"
],
"properties": {
"Reference": {
"$ref": "#/definitions/FQName"
}
},
"description": "Reference to a defined value (function or constant).\nFormat: {\"Reference\": \"package:module#name\"}\n",
"examples": [
{
"Reference": "morphir/sdk:basics#add"
},
{
"Reference": "morphir/sdk:list#map"
}
]
},
"FieldValue": {
"type": "object",
"required": [
"Field"
],
"properties": {
"Field": {
"type": "object",
"required": [
"target",
"name"
],
"properties": {
"target": {
"$ref": "#/definitions/Value"
},
"name": {
"$ref": "#/definitions/Name"
}
}
}
},
"description": "Field access on a record.\nFormat: {\"Field\": {\"target\": value, \"name\": \"field-name\"}}\n",
"examples": [
{
"Field": {
"target": {
"Variable": "record"
},
"name": "field-name"
}
}
]
},
"FieldFunctionValue": {
"type": "object",
"required": [
"FieldFunction"
],
"properties": {
"FieldFunction": {
"$ref": "#/definitions/Name"
}
},
"description": "A function that extracts a field.\nFormat: {\"FieldFunction\": \"field-name\"}\n",
"examples": [
{
"FieldFunction": "name"
},
{
"FieldFunction": "age"
}
]
},
"ApplyValue": {
"type": "object",
"required": [
"Apply"
],
"properties": {
"Apply": {
"type": "object",
"required": [
"function",
"argument"
],
"properties": {
"function": {
"$ref": "#/definitions/Value"
},
"argument": {
"$ref": "#/definitions/Value"
}
}
}
},
"description": "Function application.\nFormat: {\"Apply\": {\"function\": value, \"argument\": value}}\n",
"examples": [
{
"Apply": {
"function": {
"Reference": "morphir/sdk:basics#add"
},
"argument": {
"Literal": {
"IntegerLiteral": 1
}
}
}
}
]
},
"LambdaValue": {
"type": "object",
"required": [
"Lambda"
],
"properties": {
"Lambda": {
"type": "object",
"required": [
"pattern",
"body"
],
"properties": {
"pattern": {
"$ref": "#/definitions/Pattern"
},
"body": {
"$ref": "#/definitions/Value"
}
}
}
},
"description": "Anonymous function (lambda).\nFormat: {\"Lambda\": {\"pattern\": pattern, \"body\": value}}\n",
"examples": [
{
"Lambda": {
"pattern": {
"AsPattern": {
"pattern": {
"WildcardPattern": {}
},
"name": "x"
}
},
"body": {
"Variable": "x"
}
}
}
]
},
"LetDefinitionValue": {
"type": "object",
"required": [
"LetDefinition"
],
"properties": {
"LetDefinition": {
"type": "object",
"required": [
"name",
"definition",
"in"
],
"properties": {
"name": {
"$ref": "#/definitions/Name"
},
"definition": {
"$ref": "#/definitions/ValueDefinition"
},
"in": {
"$ref": "#/definitions/Value"
}
}
}
},
"description": "Let binding introducing a single value.\nFormat: {\"LetDefinition\": {\"name\": \"x\", \"definition\": {...}, \"in\": value}}\n",
"examples": [
{
"LetDefinition": {
"name": "x",
"definition": {},
"in": {
"Variable": "x"
}
}
}
]
},
"LetRecursionValue": {
"type": "object",
"required": [
"LetRecursion"
],
"properties": {
"LetRecursion": {
"type": "object",
"required": [
"definitions",
"in"
],
"properties": {
"definitions": {
"type": "object",
"additionalProperties": {
"$ref": "#/definitions/ValueDefinition"
}
},
"in": {
"$ref": "#/definitions/Value"
}
}
}
},
"description": "Mutually recursive let bindings.\nFormat: {\"LetRecursion\": {\"definitions\": {\"f\": {...}, \"g\": {...}}, \"in\": value}}\n",
"examples": [
{
"LetRecursion": {
"definitions": {
"f": {},
"g": {}
},
"in": {
"Variable": "f"
}
}
}
]
},
"DestructureValue": {
"type": "object",
"required": [
"Destructure"
],
"properties": {
"Destructure": {
"type": "object",
"required": [
"pattern",
"value",
"in"
],
"properties": {
"pattern": {
"$ref": "#/definitions/Pattern"
},
"value": {
"$ref": "#/definitions/Value"
},
"in": {
"$ref": "#/definitions/Value"
}
}
}
},
"description": "Pattern-based destructuring.\nFormat: {\"Destructure\": {\"pattern\": pattern, \"value\": value, \"in\": value}}\n"
},
"IfThenElseValue": {
"type": "object",
"required": [
"IfThenElse"
],
"properties": {
"IfThenElse": {
"type": "object",
"required": [
"condition",
"then",
"else"
],
"properties": {
"condition": {
"$ref": "#/definitions/Value"
},
"then": {
"$ref": "#/definitions/Value"
},
"else": {
"$ref": "#/definitions/Value"
}
}
}
},
"description": "Conditional expression.\nFormat: {\"IfThenElse\": {\"condition\": value, \"then\": value, \"else\": value}}\n"
},
"PatternMatchValue": {
"type": "object",
"required": [
"PatternMatch"
],
"properties": {
"PatternMatch": {
"type": "object",
"required": [
"value",
"cases"
],
"properties": {
"value": {
"$ref": "#/definitions/Value"
},
"cases": {
"type": "array",
"items": {
"type": "object",
"required": [
"pattern",
"body"
],
"properties": {
"pattern": {
"$ref": "#/definitions/Pattern"
},
"body": {
"$ref": "#/definitions/Value"
}
}
}
}
}
}
},
"description": "Pattern matching with multiple cases.\nFormat: {\"PatternMatch\": {\"value\": value, \"cases\": [{\"pattern\": ..., \"body\": ...}, ...]}}\n"
},
"UpdateRecordValue": {
"type": "object",
"required": [
"UpdateRecord"
],
"properties": {
"UpdateRecord": {
"type": "object",
"required": [
"target",
"fields"
],
"properties": {
"target": {
"$ref": "#/definitions/Value"
},
"fields": {
"type": "object",
"additionalProperties": {
"$ref": "#/definitions/Value"
}
}
}
}
},
"description": "Record update expression.\nFormat: {\"UpdateRecord\": {\"target\": value, \"fields\": {\"field-name\": value, ...}}}\n",
"examples": [
{
"UpdateRecord": {
"target": {
"Variable": "record"
},
"fields": {
"name": {
"Literal": {
"StringLiteral": "new"
}
}
}
}
}
]
},
"UnitValue": {
"type": "object",
"required": [
"Unit"
],
"properties": {
"Unit": {
"type": "object"
}
},
"description": "The unit value.\nFormat: {\"Unit\": {}}\n",
"examples": [
{
"Unit": {}
}
]
},
"Pattern": {
"oneOf": [
{
"$ref": "#/definitions/WildcardPattern"
},
{
"$ref": "#/definitions/AsPattern"
},
{
"$ref": "#/definitions/TuplePattern"
},
{
"$ref": "#/definitions/ConstructorPattern"
},
{
"$ref": "#/definitions/EmptyListPattern"
},
{
"$ref": "#/definitions/HeadTailPattern"
},
{
"$ref": "#/definitions/LiteralPattern"
},
{
"$ref": "#/definitions/UnitPattern"
}
]
},
"WildcardPattern": {
"type": "object",
"required": [
"WildcardPattern"
],
"properties": {
"WildcardPattern": {
"type": "object"
}
},
"description": "Wildcard pattern (matches anything).\nFormat: {\"WildcardPattern\": {}}\n",
"examples": [
{
"WildcardPattern": {}
}
]
},
"AsPattern": {
"type": "object",
"required": [
"AsPattern"
],
"properties": {
"AsPattern": {
"type": "object",
"required": [
"pattern",
"name"
],
"properties": {
"pattern": {
"$ref": "#/definitions/Pattern"
},
"name": {
"$ref": "#/definitions/Name"
}
}
}
},
"description": "As pattern (binds matched value to a name).\nFormat: {\"AsPattern\": {\"pattern\": pattern, \"name\": \"x\"}}\n",
"examples": [
{
"AsPattern": {
"pattern": {
"WildcardPattern": {}
},
"name": "x"
}
}
]
},
"TuplePattern": {
"oneOf": [
{
"type": "array",
"items": {
"$ref": "#/definitions/Pattern"
},
"description": "Bare array of patterns. Unambiguous because no other pattern type uses bare arrays.\n"
},
{
"type": "object",
"required": [
"TuplePattern"
],
"additionalProperties": false,
"properties": {
"TuplePattern": {
"type": "array",
"items": {
"$ref": "#/definitions/Pattern"
}
}
},
"description": "Canonical wrapper format with array of patterns.\n"
},
{
"type": "object",
"required": [
"TuplePattern"
],
"additionalProperties": false,
"properties": {
"TuplePattern": {
"type": "object",
"required": [
"patterns"
],
"properties": {
"patterns": {
"type": "array",
"items": {
"$ref": "#/definitions/Pattern"
}
}
}
}
},
"description": "Expanded wrapper format with explicit patterns field.\n"
}
],
"description": "Tuple pattern for destructuring tuples.\n\nCanonical: {\"TuplePattern\": [pattern1, pattern2, ...]}\n\nAccepted formats:\n- Bare array: [pattern1, pattern2, ...]\n- Wrapper with array: {\"TuplePattern\": [pattern1, pattern2, ...]}\n- Wrapper with object: {\"TuplePattern\": {\"patterns\": [pattern1, pattern2, ...]}}\n\nEncoders should output canonical form.\n",
"examples": [
[
{
"WildcardPattern": {}
},
{
"AsPattern": {
"pattern": {
"WildcardPattern": {}
},
"name": "x"
}
}
],
{
"TuplePattern": [
{
"WildcardPattern": {}
},
{
"AsPattern": {
"pattern": {
"WildcardPattern": {}
},
"name": "x"
}
}
]
},
{
"TuplePattern": {
"patterns": [
{
"WildcardPattern": {}
},
{
"AsPattern": {
"pattern": {
"WildcardPattern": {}
},
"name": "x"
}
}
]
}
}
]
},
"ConstructorPattern": {
"type": "object",
"required": [
"ConstructorPattern"
],
"properties": {
"ConstructorPattern": {
"type": "object",
"required": [
"fqname",
"patterns"
],
"properties": {
"fqname": {
"$ref": "#/definitions/FQName"
},
"patterns": {
"type": "array",
"items": {
"$ref": "#/definitions/Pattern"
}
}
}
}
},
"description": "Constructor pattern for custom type matching.\nFormat: {\"ConstructorPattern\": {\"fqname\": \"package:module#ctor\", \"patterns\": [...]}}\n",
"examples": [
{
"ConstructorPattern": {
"fqname": "morphir/sdk:maybe#just",
"patterns": [
{
"AsPattern": {
"pattern": {
"WildcardPattern": {}
},
"name": "x"
}
}
]
}
}
]
},
"EmptyListPattern": {
"type": "object",
"required": [
"EmptyListPattern"
],
"properties": {
"EmptyListPattern": {
"type": "object"
}
},
"description": "Pattern matching an empty list.\nFormat: {\"EmptyListPattern\": {}}\n",
"examples": [
{
"EmptyListPattern": {}
}
]
},
"HeadTailPattern": {
"type": "object",
"required": [
"HeadTailPattern"
],
"properties": {
"HeadTailPattern": {
"type": "object",
"required": [
"head",
"tail"
],
"properties": {
"head": {
"$ref": "#/definitions/Pattern"
},
"tail": {
"$ref": "#/definitions/Pattern"
}
}
}
},
"description": "Pattern matching head and tail of a list.\nFormat: {\"HeadTailPattern\": {\"head\": pattern, \"tail\": pattern}}\n",
"examples": [
{
"HeadTailPattern": {
"head": {
"AsPattern": {
"pattern": {
"WildcardPattern": {}
},
"name": "x"
}
},
"tail": {
"AsPattern": {
"pattern": {
"WildcardPattern": {}
},
"name": "xs"
}
}
}
}
]
},
"LiteralPattern": {
"type": "object",
"required": [
"LiteralPattern"
],
"properties": {
"LiteralPattern": {
"oneOf": [
{
"type": "boolean"
},
{
"type": "number"
},
{
"type": "string"
},
{
"$ref": "#/definitions/Literal"
},
{
"type": "object",
"required": [
"literal"
],
"properties": {
"attributes": {
"$ref": "#/definitions/ValueAttributes"
},
"literal": {
"oneOf": [
{
"type": "boolean"
},
{
"type": "number"
},
{
"type": "string"
},
{
"$ref": "#/definitions/Literal"
}
]
}
}
}
]
}
},
"description": "Pattern matching a literal value. Multiple forms accepted:\n\n- Most compact: { \"LiteralPattern\": 42 }\n- Compact with type: { \"LiteralPattern\": { \"IntegerLiteral\": 42 } }\n- Expanded: { \"LiteralPattern\": { \"attributes\": {...}, \"literal\": { \"IntegerLiteral\": 42 } } }\n\nEncoders should prefer the most compact unambiguous form.\n",
"examples": [
{
"LiteralPattern": 42
},
{
"LiteralPattern": "hello"
},
{
"LiteralPattern": {
"IntegerLiteral": 42
}
},
{
"LiteralPattern": {
"StringLiteral": "hello"
}
}
]
},
"UnitPattern": {
"type": "object",
"required": [
"UnitPattern"
],
"properties": {
"UnitPattern": {
"type": "object"
}
},
"description": "Pattern matching the unit value.\nFormat: {\"UnitPattern\": {}}\n",
"examples": [
{
"UnitPattern": {}
}
]
},
"ValueSpecification": {
"type": "object",
"required": [
"output"
],
"properties": {
"annotations": {
"type": "array",
"items": {
"$ref": "#/definitions/Annotation"
}
},
"inputs": {
"oneOf": [
{
"type": "object",
"additionalProperties": {
"$ref": "#/definitions/Type"
}
},
{
"type": "array",
"items": {
"type": "array",
"items": [
{
"$ref": "#/definitions/Name"
},
{
"$ref": "#/definitions/Type"
}
]
}
}
],
"description": "Input parameters.\nCanonical (output): Object keyed by parameter name: { \"x\": type, \"y\": type }\nAccepted (input): Array format: [[\"x\", type], [\"y\", type]]\nCan be omitted if empty (no inputs).\n"
},
"output": {
"$ref": "#/definitions/Type"
},
"doc": {
"type": "string",
"description": "Optional documentation for this value"
}
},
"description": "Value specification (public interface - signature only, no implementation).\n\nCanonical format: { \"inputs\": { \"a\": type, \"b\": type }, \"output\": type }\nThe \"inputs\" field can be omitted if empty.\n\nEncoders should output the canonical object format.\nDecoders should accept both object and legacy array formats.\n",
"examples": [
{
"inputs": {
"a": "morphir/sdk:basics#int",
"b": "morphir/sdk:basics#int"
},
"output": "morphir/sdk:basics#int"
},
{
"output": "morphir/sdk:basics#int"
},
{
"inputs": {},
"output": "morphir/sdk:string#string",
"doc": "Returns a greeting"
}
]
},
"ValueDefinition": {
"oneOf": [
{
"type": "object",
"required": [
"ExpressionBody"
],
"additionalProperties": false,
"properties": {
"ExpressionBody": {
"$ref": "#/definitions/ExpressionBody"
}
}
},
{
"type": "object",
"required": [
"NativeBody"
],
"additionalProperties": false,
"properties": {
"NativeBody": {
"$ref": "#/definitions/NativeBody"
}
}
},
{
"type": "object",
"required": [
"ExternalBody"
],
"additionalProperties": false,
"properties": {
"ExternalBody": {
"$ref": "#/definitions/ExternalBody"
}
}
},
{
"type": "object",
"required": [
"IncompleteBody"
],
"additionalProperties": false,
"properties": {
"IncompleteBody": {
"$ref": "#/definitions/IncompleteBody"
}
}
}
],
"description": "Value definition body variant. When wrapped in AccessControlled (as in ModuleDefinition.values),\nthe structure is: { \"access\": \"Public\", \"ExpressionBody\": { ... } } or similar for other variants.\nThe wrapper object format uses the variant name as a key.\n"
},
"ExpressionBody": {
"type": "object",
"required": [
"inputTypes",
"outputType",
"body"
],
"properties": {
"inputTypes": {
"type": "object",
"additionalProperties": {
"$ref": "#/definitions/Type"
},
"description": "Dictionary mapping input parameter names to their types.\nV4 uses object format: { \"param-name\": type, ... }\n"
},
"outputType": {
"$ref": "#/definitions/Type"
},
"body": {
"$ref": "#/definitions/Value"
}
},
"description": "Normal IR expression body with input types, output type, and expression body.\nUsed for most value definitions.\n",
"examples": [
{
"inputTypes": {
"x": "morphir/sdk:basics#int"
},
"outputType": "morphir/sdk:basics#int",
"body": {
"Variable": {
"attributes": {},
"name": "x"
}
}
},
{
"inputTypes": {
"tables": "regulation:data-tables#data-tables"
},
"outputType": "morphir/sdk:basics#float",
"body": {
"Literal": {
"attributes": {},
"literal": {
"FloatLiteral": 0
}
}
}
}
]
},
"NativeBody": {
"type": "object",
"required": [
"inputTypes",
"outputType",
"nativeInfo"
],
"properties": {
"inputTypes": {
"type": "object",
"additionalProperties": {
"$ref": "#/definitions/Type"
},
"description": "Dictionary mapping input parameter names to their types.\nV4 uses object format: { \"param-name\": type, ... }\n"
},
"outputType": {
"$ref": "#/definitions/Type"
},
"nativeInfo": {
"$ref": "#/definitions/NativeInfo"
}
},
"description": "Native/builtin operation body (no IR expression).\nUsed for platform operations that don't have an IR representation.\n",
"examples": [
{
"inputTypes": {
"a": "morphir/sdk:basics#int",
"b": "morphir/sdk:basics#int"
},
"outputType": "morphir/sdk:basics#int",
"nativeInfo": {
"hint": {
"Arithmetic": {}
}
}
}
]
},
"ExternalBody": {
"type": "object",
"required": [
"inputTypes",
"outputType",
"externalName",
"targetPlatform"
],
"properties": {
"inputTypes": {
"type": "object",
"additionalProperties": {
"$ref": "#/definitions/Type"
},
"description": "Dictionary mapping input parameter names to their types.\nV4 uses object format: { \"param-name\": type, ... }\n"
},
"outputType": {
"$ref": "#/definitions/Type"
},
"externalName": {
"type": "string",
"description": "Name of the external function/operation"
},
"targetPlatform": {
"type": "string",
"description": "Target platform identifier (e.g., 'wasm', 'native')"
}
},
"description": "External FFI call body (no IR expression).\nUsed for foreign function interface calls to platform-specific code.\n",
"examples": [
{
"inputTypes": {
"msg": "morphir/sdk:string#string"
},
"outputType": "morphir/sdk:basics#unit",
"externalName": "console.log",
"targetPlatform": "javascript"
}
]
},
"IncompleteBody": {
"type": "object",
"required": [
"inputTypes",
"incompleteness"
],
"properties": {
"inputTypes": {
"type": "object",
"additionalProperties": {
"$ref": "#/definitions/Type"
},
"description": "Dictionary mapping input parameter names to their types.\nV4 uses object format: { \"param-name\": type, ... }\n"
},
"outputType": {
"$ref": "#/definitions/Type"
},
"incompleteness": {
"$ref": "#/definitions/Incompleteness"
},
"partialBody": {
"$ref": "#/definitions/Value"
}
},
"description": "Incomplete definition body (V4 feature for best-effort support).\nUsed when a definition cannot be fully resolved (e.g., deleted reference, type mismatch).\n",
"examples": [
{
"inputTypes": {
"x": "morphir/sdk:basics#int"
},
"outputType": "morphir/sdk:basics#int",
"incompleteness": {
"Hole": {
"reason": {
"UnresolvedReference": {
"target": "my-org/project:module#deleted-function"
}
}
}
}
}
]
},
"Literal": {
"oneOf": [
{
"$ref": "#/definitions/BoolLiteral"
},
{
"$ref": "#/definitions/CharLiteral"
},
{
"$ref": "#/definitions/StringLiteral"
},
{
"$ref": "#/definitions/IntegerLiteral"
},
{
"$ref": "#/definitions/FloatLiteral"
},
{
"$ref": "#/definitions/DecimalLiteral"
}
],
"description": "Literal constant value. V4 uses wrapper object format.\n\nTwo forms are accepted (permissive decoding):\n- Compact (canonical): { \"IntegerLiteral\": 42 }\n- Expanded: { \"IntegerLiteral\": { \"value\": 42 } }\n\nEncoders should output the compact form.\n"
},
"BoolLiteral": {
"type": "object",
"required": [
"BoolLiteral"
],
"additionalProperties": false,
"properties": {
"BoolLiteral": {
"oneOf": [
{
"type": "boolean"
},
{
"type": "object",
"required": [
"value"
],
"properties": {
"value": {
"type": "boolean"
}
}
}
]
}
},
"description": "Boolean literal.\nCompact: { \"BoolLiteral\": true }\nExpanded: { \"BoolLiteral\": { \"value\": true } }\n",
"examples": [
{
"BoolLiteral": true
},
{
"BoolLiteral": false
}
]
},
"CharLiteral": {
"type": "object",
"required": [
"CharLiteral"
],
"additionalProperties": false,
"properties": {
"CharLiteral": {
"oneOf": [
{
"type": "string",
"minLength": 1,
"maxLength": 1
},
{
"type": "object",
"required": [
"value"
],
"properties": {
"value": {
"type": "string",
"minLength": 1,
"maxLength": 1
}
}
}
]
}
},
"description": "Character literal (single character).\nCompact: { \"CharLiteral\": \"A\" }\nExpanded: { \"CharLiteral\": { \"value\": \"A\" } }\n",
"examples": [
{
"CharLiteral": "A"
},
{
"CharLiteral": "\n"
}
]
},
"StringLiteral": {
"type": "object",
"required": [
"StringLiteral"
],
"additionalProperties": false,
"properties": {
"StringLiteral": {
"oneOf": [
{
"type": "string"
},
{
"type": "object",
"required": [
"value"
],
"properties": {
"value": {
"type": "string"
}
}
}
]
}
},
"description": "String literal.\nCompact: { \"StringLiteral\": \"hello\" }\nExpanded: { \"StringLiteral\": { \"value\": \"hello\" } }\n",
"examples": [
{
"StringLiteral": "hello world"
},
{
"StringLiteral": ""
}
]
},
"IntegerLiteral": {
"type": "object",
"required": [
"IntegerLiteral"
],
"additionalProperties": false,
"properties": {
"IntegerLiteral": {
"oneOf": [
{
"type": "integer"
},
{
"type": "object",
"required": [
"value"
],
"properties": {
"value": {
"type": "integer"
}
}
}
]
}
},
"description": "Integer literal (arbitrary precision, includes negatives).\nV4 renamed from WholeNumberLiteral for correctness.\nCompact: { \"IntegerLiteral\": 42 }\nExpanded: { \"IntegerLiteral\": { \"value\": 42 } }\n",
"examples": [
{
"IntegerLiteral": 42
},
{
"IntegerLiteral": -100
},
{
"IntegerLiteral": 0
}
]
},
"FloatLiteral": {
"type": "object",
"required": [
"FloatLiteral"
],
"additionalProperties": false,
"properties": {
"FloatLiteral": {
"oneOf": [
{
"type": "number"
},
{
"type": "object",
"required": [
"value"
],
"properties": {
"value": {
"type": "number"
}
}
}
]
}
},
"description": "Floating-point literal.\nCompact: { \"FloatLiteral\": 3.14 }\nExpanded: { \"FloatLiteral\": { \"value\": 3.14 } }\n",
"examples": [
{
"FloatLiteral": 3.14159
},
{
"FloatLiteral": -0.5
},
{
"FloatLiteral": 10000000000
}
]
},
"DecimalLiteral": {
"type": "object",
"required": [
"DecimalLiteral"
],
"additionalProperties": false,
"properties": {
"DecimalLiteral": {
"oneOf": [
{
"type": "string"
},
{
"type": "object",
"required": [
"value"
],
"properties": {
"value": {
"type": "string"
}
}
}
]
}
},
"description": "Arbitrary-precision decimal literal (stored as string for precision).\nCompact: { \"DecimalLiteral\": \"123.456789012345678901234567890\" }\nExpanded: { \"DecimalLiteral\": { \"value\": \"123.456789012345678901234567890\" } }\n",
"examples": [
{
"DecimalLiteral": "123456789.987654321"
},
{
"DecimalLiteral": "0.000000000000000001"
}
]
},
"NativeInfo": {
"type": "object",
"required": [
"hint"
],
"properties": {
"hint": {
"$ref": "#/definitions/NativeHint"
},
"description": {
"type": "string",
"description": "Optional human-readable description of the native operation"
}
},
"description": "Information about a native operation. Used in NativeBody to categorize\nplatform operations for optimization and code generation.\n",
"examples": [
{
"hint": {
"Arithmetic": {}
}
},
{
"hint": {
"CollectionOp": {}
},
"description": "List map operation"
},
{
"hint": {
"PlatformSpecific": {
"platform": "wasm"
}
}
}
]
},
"NativeHint": {
"oneOf": [
{
"type": "object",
"required": [
"Arithmetic"
],
"additionalProperties": false,
"properties": {
"Arithmetic": {}
},
"description": "Basic arithmetic/logic operation (add, subtract, multiply, etc.)"
},
{
"type": "object",
"required": [
"Comparison"
],
"additionalProperties": false,
"properties": {
"Comparison": {}
},
"description": "Comparison operation (equals, less than, greater than, etc.)"
},
{
"type": "object",
"required": [
"StringOp"
],
"additionalProperties": false,
"properties": {
"StringOp": {}
},
"description": "String operation (concat, split, etc.)"
},
{
"type": "object",
"required": [
"CollectionOp"
],
"additionalProperties": false,
"properties": {
"CollectionOp": {}
},
"description": "Collection operation (map, filter, fold, etc.)"
},
{
"type": "object",
"required": [
"PlatformSpecific"
],
"additionalProperties": false,
"properties": {
"PlatformSpecific": {
"type": "object",
"required": [
"platform"
],
"properties": {
"platform": {
"type": "string",
"description": "Platform identifier (e.g., 'wasm', 'javascript', 'native')"
}
}
}
},
"description": "Platform-specific operation"
}
],
"description": "Categorization hint for native operations. Used by code generators\nto select appropriate implementations or optimizations.\n",
"examples": [
{
"Arithmetic": {}
},
{
"Comparison": {}
},
{
"StringOp": {}
},
{
"CollectionOp": {}
},
{
"PlatformSpecific": {
"platform": "wasm"
}
}
]
},
"Incompleteness": {
"oneOf": [
{
"type": "object",
"required": [
"Hole"
],
"additionalProperties": false,
"properties": {
"Hole": {
"type": "object",
"required": [
"reason"
],
"properties": {
"reason": {
"$ref": "#/definitions/HoleReason"
},
"partialBody": {
"$ref": "#/definitions/Type",
"description": "Optional partial type information if available"
}
}
}
},
"description": "Hole due to unresolved reference or error"
},
{
"type": "object",
"required": [
"Draft"
],
"additionalProperties": false,
"properties": {
"Draft": {}
},
"description": "Author-marked work-in-progress"
}
],
"description": "Reason for incomplete type or value definition. V4 feature for\nbest-effort IR generation when full resolution isn't possible.\n",
"examples": [
{
"Hole": {
"reason": {
"UnresolvedReference": {
"target": "my-org/project:module#deleted-function"
}
}
}
},
{
"Draft": {}
}
]
},
"HoleReason": {
"oneOf": [
{
"type": "object",
"required": [
"UnresolvedReference"
],
"additionalProperties": false,
"properties": {
"UnresolvedReference": {
"type": "object",
"required": [
"target"
],
"properties": {
"target": {
"$ref": "#/definitions/FQName",
"description": "The FQName that could not be resolved"
}
}
}
},
"description": "Reference to something that doesn't exist or was deleted"
},
{
"type": "object",
"required": [
"DeletedDuringRefactor"
],
"additionalProperties": false,
"properties": {
"DeletedDuringRefactor": {
"type": "object",
"required": [
"tx-id"
],
"properties": {
"tx-id": {
"type": "string",
"description": "Transaction ID of the refactoring that deleted this reference"
}
}
}
},
"description": "Reference was deleted during a refactoring operation"
},
{
"type": "object",
"required": [
"TypeMismatch"
],
"additionalProperties": false,
"properties": {
"TypeMismatch": {
"type": "object",
"required": [
"expected",
"found"
],
"properties": {
"expected": {
"type": "string",
"description": "Expected type description"
},
"found": {
"type": "string",
"description": "Actual type description"
}
}
}
},
"description": "Type mismatch error"
}
],
"description": "Specific reason why a Hole exists in the IR. Used for error reporting\nand to guide developers in fixing incomplete definitions.\n",
"examples": [
{
"UnresolvedReference": {
"target": "my-org/project:module#missing-function"
}
},
{
"DeletedDuringRefactor": {
"tx-id": "refactor-2024-01-15-abc123"
}
},
{
"TypeMismatch": {
"expected": "Int",
"found": "String"
}
}
]
}
}
}
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| slack-gif-creatoranthropics/skillsKnowledge and utilities for creating animated GIFs optimized for Slack. Provides constraints, validation tools, and animation concepts. Use when users request animated GIFs for Slack like "make me a GIF of X doing Y for Slack." | Stars: 198k | Updated | Claude CodeCodex | Verified | Install |
| ponytailDietrichGebert/ponytailLazy senior dev mode for any coding task: the smallest change that fully solves it, and a reply a busy human understands in one read. | Stars: 194k | Updated | Claude CodeCodex | Verified | Install |
| ponytail-debtDietrichGebert/ponytailHarvest every shortcut: comment into one debt ledger, so deferrals get tracked instead of forgotten. One-shot report. | Stars: 194k | Updated | Claude CodeCodex | Verified | Install |
| ponytail-debtDietrichGebert/ponytailList every `shortcut:` comment (and older `ponytail:` ones) as a debt ledger. One-shot report, changes nothing. Use for "ponytail debt", "what did ponytail defer", "list the shortcuts", /ponytail-debt. | Stars: 194k | Updated | Claude CodeCodex | Verified | Install |