@neocompose/cli 0.27.1 → 0.29.0

package/dist/neo.mjs

@@ -1813,6 +1813,9 @@ var init_generated_csharp_identifiers = __esm({
 });
 
 // ../packages/neoscript-language/src/project.ts
+function neoScriptParameterIsOmittable(parameter4) {
+  return parameter4.defaultValue !== void 0;
+}
 function neoScriptRequiredConstructor(type) {
   return type?.declaredConstructors?.find(
     (candidate) => candidate.required === true
@@ -1820,7 +1823,7 @@ function neoScriptRequiredConstructor(type) {
 }
 function neoScriptParameterlessConstructor(type) {
   return type.declaredConstructors?.find(
-    (candidate) => candidate.parameters.length === 0
+    (candidate) => candidate.parameters.every(neoScriptParameterIsOmittable)
   ) ?? null;
 }
 function isNeoScriptConstructionDocumentKind(kind) {
@@ -2357,11 +2360,11 @@ function signatureHelp(snapshot, position) {
       return {
         signatures: declared.map((candidate) => ({
           label: `${type.name}(${candidate.parameters.map(
-            (parameter4) => `${formatType(parameter4.type, snapshot.project)} ${parameter4.name}`
+            (parameter4) => `${formatType(parameter4.type, snapshot.project)} ${parameter4.name}${parameterDefaultSuffix(parameter4)}`
           ).join(", ")})`,
           ...candidate.documentation ? { documentation: candidate.documentation } : {},
           parameters: candidate.parameters.map((parameter4) => ({
-            label: `${formatType(parameter4.type, snapshot.project)} ${parameter4.name}`,
+            label: `${formatType(parameter4.type, snapshot.project)} ${parameter4.name}${parameterDefaultSuffix(parameter4)}`,
             ...parameter4.documentation ? { documentation: parameter4.documentation } : {}
           }))
         })),
@@ -2404,7 +2407,7 @@ function signatureHelp(snapshot, position) {
         label: formatSymbolSignature(symbol, snapshot.project),
         ...symbol.documentation ? { documentation: symbol.documentation } : {},
         parameters: symbol.parameters.map((parameter4) => ({
-          label: `${formatType(parameter4.type, snapshot.project)} ${parameter4.name}`,
+          label: `${formatType(parameter4.type, snapshot.project)} ${parameter4.name}${parameterDefaultSuffix(parameter4)}`,
           ...parameter4.documentation ? { documentation: parameter4.documentation } : {}
         }))
       }
@@ -4140,9 +4143,14 @@ function displaySymbolKind(symbol) {
   }
   return symbol.kind.charAt(0).toUpperCase() + symbol.kind.slice(1);
 }
+function parameterDefaultSuffix(parameter4) {
+  return parameter4.defaultValue === void 0 ? "" : ` = ${parameter4.defaultValue.displayText}`;
+}
 function formatSymbolSignature(symbol, project) {
   if (symbol.parameters !== void 0) {
-    const parameters = symbol.parameters.map((item) => `${formatType(item.type, project)} ${item.name}`).join(", ");
+    const parameters = symbol.parameters.map(
+      (item) => `${formatType(item.type, project)} ${item.name}${parameterDefaultSuffix(item)}`
+    ).join(", ");
     const returnType = symbol.returnType ?? symbol.type;
     const deferred = symbol.deferred ? "Task<" : "";
     const end = symbol.deferred ? ">" : "";
@@ -7323,11 +7331,24 @@ var init_strict_parser = __esm({
 function neoScriptArgumentNameSetKey(names) {
   return [...names].map((name) => name.toLowerCase()).sort().join(",");
 }
-function parameterNameSetKey(parameters) {
-  return neoScriptArgumentNameSetKey(
-    parameters.map((parameter4) => parameter4.name)
+function neoScriptCallMatchesParameters(suppliedNames, parameters) {
+  const supplied = new Set(suppliedNames.map((name) => name.toLowerCase()));
+  const declared = new Set(
+    parameters.map((parameter4) => parameter4.name.toLowerCase())
+  );
+  for (const name of supplied) {
+    if (!declared.has(name)) return false;
+  }
+  return parameters.every(
+    (parameter4) => parameter4.defaulted || supplied.has(parameter4.name.toLowerCase())
   );
 }
+function callableShape(parameters) {
+  return parameters.map((parameter4) => ({
+    name: parameter4.name,
+    defaulted: neoScriptParameterIsOmittable(parameter4)
+  }));
+}
 function neoScriptPositionalTypeKey(type) {
   switch (type.kind) {
     case "primitive":
@@ -7385,8 +7406,108 @@ function validateNeoScriptOverloadSignatures(className, signatures) {
       message: `Class '${className}' declares constructors (${parameterLists.join(") and (")}) that differ only by parameter name; generated C# would emit the same constructor signature twice.`
     });
   }
+  errors.push(...defaultedTieErrors(className, signatures));
+  errors.push(...effectiveArityCollisionErrors(className, signatures));
   return errors;
 }
+function defaultedTieErrors(className, signatures) {
+  const errors = [];
+  for (let first = 0; first < signatures.length; first += 1) {
+    for (let second = first + 1; second < signatures.length; second += 1) {
+      const left = signatures[first];
+      const right = signatures[second];
+      if (left === void 0 || right === void 0) continue;
+      if (namedSignatureKey(left) === namedSignatureKey(right)) continue;
+      if (left.parameters.length !== right.parameters.length) continue;
+      const leftHasDefault = left.parameters.some(
+        (parameter4) => parameter4.defaulted === true
+      );
+      const rightHasDefault = right.parameters.some(
+        (parameter4) => parameter4.defaulted === true
+      );
+      if (!leftHasDefault && !rightHasDefault) continue;
+      const tyingCall = tyingCallNames(left, right);
+      if (tyingCall === null) continue;
+      const callDescription = tyingCall.length === 0 ? "`new()`" : `\`new(${tyingCall.join(": \u2026, ")}: \u2026)\``;
+      errors.push({
+        kind: "duplicateNameSet",
+        constructorIds: [left.id, right.id],
+        message: `Class '${className}' declares constructors (${describeSignatureParameters(left)}) and (${describeSignatureParameters(right)}) that the call ${callDescription} would match with the same number of defaulted fill-ins and the same argument types; no call site could resolve between them.`
+      });
+    }
+  }
+  return errors;
+}
+function tyingCallNames(left, right) {
+  const leftTypes = new Map(
+    left.parameters.map((parameter4) => [
+      parameter4.name.toLowerCase(),
+      parameter4.typeKey
+    ])
+  );
+  const rightTypes = new Map(
+    right.parameters.map((parameter4) => [
+      parameter4.name.toLowerCase(),
+      parameter4.typeKey
+    ])
+  );
+  const tying = /* @__PURE__ */ new Map();
+  for (const parameter4 of [...left.parameters, ...right.parameters]) {
+    if (parameter4.defaulted === true) continue;
+    tying.set(parameter4.name.toLowerCase(), parameter4.name);
+  }
+  for (const name of tying.keys()) {
+    const leftType = leftTypes.get(name);
+    const rightType = rightTypes.get(name);
+    if (leftType === void 0) return null;
+    if (rightType === void 0) return null;
+    if (leftType !== rightType) return null;
+  }
+  return [...tying.values()];
+}
+function effectiveArityCollisionErrors(className, signatures) {
+  const errors = [];
+  const byEffectiveKey = /* @__PURE__ */ new Map();
+  for (const signature of signatures) {
+    const minimumArity = signature.parameters.filter(
+      (parameter4) => parameter4.defaulted !== true
+    ).length;
+    for (let arity = minimumArity; arity <= signature.parameters.length; arity += 1) {
+      const key = signature.parameters.slice(0, arity).map((parameter4) => parameter4.typeKey).join(",");
+      byEffectiveKey.set(key, [
+        ...byEffectiveKey.get(key) ?? [],
+        { signature, arity }
+      ]);
+    }
+  }
+  const reportedPairs = /* @__PURE__ */ new Set();
+  for (const entries of byEffectiveKey.values()) {
+    if (entries.length < 2) continue;
+    const shortened = entries.some(
+      (entry) => entry.arity < entry.signature.parameters.length
+    );
+    if (!shortened) continue;
+    const ids = entries.map((entry) => entry.signature.id);
+    const pairKey = [...ids].sort().join("|");
+    if (reportedPairs.has(pairKey)) continue;
+    reportedPairs.add(pairKey);
+    const parameterLists = entries.map(
+      (entry) => describeSignatureParameters(entry.signature)
+    );
+    errors.push({
+      kind: "positionalCollision",
+      constructorIds: ids,
+      message: `Class '${className}' declares constructors (${parameterLists.join(") and (")}) that expose the same C# positional signature once defaulted parameters are omitted; C# would resolve the shared arity differently from NeoScript's named overloads.`
+    });
+  }
+  return errors;
+}
+function describeSignatureParameters(signature) {
+  return signature.parameters.map((parameter4) => {
+    const defaulted = parameter4.defaulted === true ? " = \u2026" : "";
+    return `${parameter4.name}${defaulted}`;
+  }).join(", ");
+}
 function namedSignatureKey(signature) {
   return [...signature.parameters].map((parameter4) => `${parameter4.name.toLowerCase()}:${parameter4.typeKey}`).sort().join(",");
 }
@@ -7397,23 +7518,35 @@ function validateNeoScriptDeclaredConstructorOverloads(className, constructors)
       id: constructor2.id,
       parameters: constructor2.parameters.map((parameter4) => ({
         name: parameter4.name,
-        typeKey: neoScriptPositionalTypeKey(parameter4.type)
+        typeKey: neoScriptPositionalTypeKey(parameter4.type),
+        defaulted: parameter4.defaultValue !== void 0
       }))
     }))
   );
 }
 function resolveNeoScriptDeclaredConstructorOverload(constructors, args) {
-  const callKey = neoScriptArgumentNameSetKey(args.map((entry) => entry.name));
-  const byName = constructors.filter(
-    (constructor2) => parameterNameSetKey(constructor2.parameters) === callKey
+  const suppliedNames = args.map((entry) => entry.name);
+  const applicable = constructors.filter(
+    (constructor2) => neoScriptCallMatchesParameters(
+      suppliedNames,
+      callableShape(constructor2.parameters)
+    )
+  );
+  if (applicable.length === 0) return { kind: "noMatch" };
+  const fewestFillIns = Math.min(
+    ...applicable.map(
+      (constructor2) => constructor2.parameters.length - args.length
+    )
+  );
+  const best = applicable.filter(
+    (constructor2) => constructor2.parameters.length - args.length === fewestFillIns
   );
-  if (byName.length === 0) return { kind: "noMatch" };
-  if (byName.length === 1) {
-    const only = byName[0];
+  if (best.length === 1) {
+    const only = best[0];
     if (!only) return { kind: "noMatch" };
     return { kind: "resolved", constructor: only };
   }
-  const byType = byName.filter(
+  const byType = best.filter(
     (constructor2) => args.every((argument2) => {
       const parameter4 = constructor2.parameters.find(
         (candidate) => candidate.name.toLowerCase() === argument2.name.toLowerCase()
@@ -7428,17 +7561,23 @@ function resolveNeoScriptDeclaredConstructorOverload(constructors, args) {
     if (!only) return { kind: "noMatch" };
     return { kind: "resolved", constructor: only };
   }
-  if (byType.length === 0) return { kind: "ambiguous", candidates: byName };
+  if (byType.length === 0) return { kind: "ambiguous", candidates: best };
   return { kind: "ambiguous", candidates: byType };
 }
 function describeNeoScriptDeclaredConstructors(className, constructors) {
   return constructors.map(
-    (constructor2) => `${className}(${constructor2.parameters.map((parameter4) => `${parameter4.name}${parameter4.required ? "" : "?"}`).join(", ")})`
+    (constructor2) => `${className}(${constructor2.parameters.map(describeParameter).join(", ")})`
   ).join(", ");
 }
+function describeParameter(parameter4) {
+  const nullability = parameter4.required ? "" : "?";
+  const defaulted = parameter4.defaultValue === void 0 ? "" : ` = ${parameter4.defaultValue.displayText}`;
+  return `${parameter4.name}${nullability}${defaulted}`;
+}
 var init_declared_constructors = __esm({
   "../packages/neoscript-language/src/declared-constructors.ts"() {
     "use strict";
+    init_project();
   }
 });
 
@@ -7752,7 +7891,7 @@ var NEOSCRIPT_COMPILER_REVISION;
 var init_strict_ir = __esm({
   "../packages/neoscript-language/src/strict-ir.ts"() {
     "use strict";
-    NEOSCRIPT_COMPILER_REVISION = 8;
+    NEOSCRIPT_COMPILER_REVISION = 9;
   }
 });
 
@@ -8829,6 +8968,12 @@ function collectReturns(statements) {
   }
   return result;
 }
+function functionArityMessage(name, minimum, maximum, got) {
+  if (minimum === maximum) {
+    return `Function '${name}' expects ${maximum} argument${maximum === 1 ? "" : "s"}, got ${got}.`;
+  }
+  return `Function '${name}' expects between ${minimum} and ${maximum} arguments, got ${got}.`;
+}
 function requireArgCount(name, args, expected, pos) {
   if (args.length === expected) return;
   throw new CompileError(
@@ -10452,9 +10597,34 @@ var init_strict_resolver = __esm({
                   expression.pos
                 );
               }
-              if (expression.args.length !== 1 || expression.argumentNames?.[0] !== "id" || expression.args[0]?.kind !== "litString" || expression.args[0].value.length === 0) {
+              const hasProvenanceArgument = expression.args.length === 2;
+              if (expression.args.length < 1 || expression.args.length > 2) {
+                throw new CompileError(
+                  "Reference<T> requires id: string and optionally withProvenance: bool.",
+                  expression.pos
+                );
+              }
+              if (expression.argumentNames?.[0] !== "id") {
                 throw new CompileError(
-                  "Reference<T> requires exactly one named id: string argument.",
+                  "Reference<T> requires id: as its first named argument.",
+                  expression.pos
+                );
+              }
+              if (expression.args[0]?.kind !== "litString" || expression.args[0].value.length === 0) {
+                throw new CompileError(
+                  "Reference<T> id must be a non-empty string literal.",
+                  expression.pos
+                );
+              }
+              if (hasProvenanceArgument && expression.argumentNames?.[1] !== "withProvenance") {
+                throw new CompileError(
+                  "Reference<T>'s second named argument must be withProvenance: bool.",
+                  expression.pos
+                );
+              }
+              if (hasProvenanceArgument && expression.args[1]?.kind !== "litBool") {
+                throw new CompileError(
+                  "Reference<T> withProvenance must be a boolean literal.",
                   expression.pos
                 );
               }
@@ -10468,7 +10638,8 @@ var init_strict_resolver = __esm({
               return {
                 pointer: {
                   type: "reference" /* Reference */,
-                  valueId: expression.args[0].value
+                  valueId: expression.args[0].value,
+                  ...expression.args[1]?.kind === "litBool" && expression.args[1].value ? { withProvenance: true } : {}
                 },
                 type: referencedType
               };
@@ -12673,9 +12844,28 @@ var init_strict_resolver = __esm({
             }));
           }
         }
-        if (argumentsList2.length !== parameters.length) {
+        const minimumArguments = parameters.filter(
+          (parameter4) => !neoScriptParameterIsOmittable(parameter4)
+        ).length;
+        if (argumentsList2.length < minimumArguments) {
           throw new CompileError(
-            `Function '${symbol.name}' expects ${parameters.length} argument${parameters.length === 1 ? "" : "s"}, got ${argumentsList2.length}.`,
+            functionArityMessage(
+              symbol.name,
+              minimumArguments,
+              parameters.length,
+              argumentsList2.length
+            ),
+            pos
+          );
+        }
+        if (argumentsList2.length > parameters.length) {
+          throw new CompileError(
+            functionArityMessage(
+              symbol.name,
+              minimumArguments,
+              parameters.length,
+              argumentsList2.length
+            ),
             pos
           );
         }
@@ -16595,12 +16785,25 @@ var init_project_source_parser = __esm({
           const annotations = this.parseAnnotations();
           const type = this.parseType();
           const name = this.expectName("parameter name");
+          let defaultValue;
+          if (this.eat("=")) {
+            const expressionStart = this.peek();
+            defaultValue = this.captureUntilTopLevel(/* @__PURE__ */ new Set([",", ")"]), false);
+            if (defaultValue.text.trim().length === 0) {
+              throw this.failure(
+                "missing-parameter-default",
+                `Parameter '${name.text}' declares '=' but no default value. Provide a constant expression or remove the '='.`,
+                expressionStart
+              );
+            }
+          }
           parameters.push({
             annotations,
             type,
             name: name.text,
             nameRange: name.range,
-            range: rangeFrom(start, name)
+            ...defaultValue ? { defaultValue } : {},
+            range: rangeFrom(start, this.previous())
           });
           if (!this.eat(",") && !this.at(")")) {
             throw this.failure(
@@ -17173,7 +17376,7 @@ var init_project_schema_contract_generated = __esm({
   "../packages/neoscript-language/src/project-schema-contract.generated.ts"() {
     "use strict";
     PROJECT_SCHEMA_MANIFEST_FORMAT_VERSION = 3;
-    PROJECT_SCHEMA_MANIFEST_CONTRACT_VERSION = "3.9";
+    PROJECT_SCHEMA_MANIFEST_CONTRACT_VERSION = "3.10";
     PROJECT_FILE_UPLOAD_BATCH_SIZE = 32;
     NEO_PROJECT_SOURCE_RECORD_CONTRACT = {
       "recordFields": {
@@ -19272,6 +19475,24 @@ var init_project_source_construction_diagnostics = __esm({
       "unbound-constructor-argument": "error",
       /** §2.6. No overload's parameter-name set matches the call. */
       "no-matching-constructor-overload": "error",
+      /**
+       * P65 §2.2. Two overload candidates tie under the subset match after the
+       * fewest-fill-ins betterness and the type tie-break; the message lists the
+       * candidates the call could not choose between.
+       */
+      "ambiguous-constructor-call": "error",
+      /**
+       * P65 §1.3. A defaulted parameter declared before a non-defaulted one.
+       * The code string is shared with `src/models/neoscript/parameter-defaults.ts`
+       * so the push guards and the compiler name one rule identically.
+       */
+      "default-before-required-parameter": "error",
+      /**
+       * P65 §1.2. A parameter default that does not fit the parameter's declared
+       * type — a `null` default on a non-nullable parameter included. Shared with
+       * the push-guard validator, like the placement code above.
+       */
+      "parameter-default-type-mismatch": "error",
       /** §2.5 g. An initializer key naming no member of the constructed class. */
       "unknown-initializer-member": "error",
       /**
@@ -19541,9 +19762,13 @@ function resolveInvokedConstructor(declaration, call, diagnostics) {
       return true;
     }
     if (headerParameters.length === 0) return true;
+    if (parameterListIsFullyDefaulted(headerParameters)) return true;
+    const mandatory = headerParameters.filter(
+      (parameter4) => parameter4.defaultValue === void 0
+    );
     diagnostics.push({
       code: "required-constructor-not-invoked",
-      message: `Class '${declaration.name}' declares the required constructor ${describeParameterList(declaration.name, headerParameters)}, so it cannot be constructed without passing ${describeNameList(headerParameters.map((parameter4) => parameter4.name))}.`,
+      message: `Class '${declaration.name}' declares the required constructor ${describeParameterList(declaration.name, headerParameters)}, so it cannot be constructed without passing ${describeNameList(mandatory.map((parameter4) => parameter4.name))}.`,
       anchor: { kind: "site" }
     });
     return true;
@@ -19553,7 +19778,7 @@ function resolveInvokedConstructor(declaration, call, diagnostics) {
   }
   if (call.argumentNames.length === 0) {
     return declaration.constructors.some(
-      (constructor2) => constructor2.parameters.length === 0
+      (constructor2) => parameterListIsFullyDefaulted(constructor2.parameters)
     );
   }
   if (declaration.constructors.length === 1) {
@@ -19565,13 +19790,17 @@ function resolveInvokedConstructor(declaration, call, diagnostics) {
     );
     return true;
   }
-  const key = argumentNameSetKey(
-    call.argumentNames.filter((name) => name !== null)
+  const suppliedNames = call.argumentNames.filter(
+    (name) => name !== null
   );
   const matches = declaration.constructors.filter(
-    (constructor2) => argumentNameSetKey(
-      constructor2.parameters.map((parameter4) => parameter4.name)
-    ) === key
+    (constructor2) => neoScriptCallMatchesParameters(
+      suppliedNames,
+      constructor2.parameters.map((parameter4) => ({
+        name: parameter4.name,
+        defaulted: parameter4.defaultValue !== void 0
+      }))
+    )
   );
   if (matches.length > 0) return true;
   diagnostics.push({
@@ -19606,7 +19835,7 @@ function validateArgumentsAgainstParameters(className, parameters, call, diagnos
     });
   });
   const missing = parameters.filter(
-    (parameter4) => !supplied.has(parameter4.name.toLowerCase())
+    (parameter4) => parameter4.defaultValue === void 0 && !supplied.has(parameter4.name.toLowerCase())
   );
   if (missing.length === 0) return;
   diagnostics.push({
@@ -19615,6 +19844,9 @@ function validateArgumentsAgainstParameters(className, parameters, call, diagnos
     anchor: { kind: "site" }
   });
 }
+function parameterListIsFullyDefaulted(parameters) {
+  return parameters.every((parameter4) => parameter4.defaultValue !== void 0);
+}
 function validateInitializerEntries(index, entry, call, diagnostics) {
   if (call.initializerNames.length === 0) return;
   const chain = baseChain(index, entry);
@@ -19746,13 +19978,12 @@ function substitute(type, bindings) {
     arguments: type.arguments.map((argument2) => substitute(argument2, bindings))
   };
 }
-function argumentNameSetKey(names) {
-  return [...names].map((name) => name.toLowerCase()).sort().join(",");
-}
 function describeParameterList(className, parameters) {
-  const rendered = parameters.map(
-    (parameter4) => `${parameter4.name}${parameter4.type.nullable ? "?" : ""}`
-  ).join(", ");
+  const rendered = parameters.map((parameter4) => {
+    const nullability = parameter4.type.nullable ? "?" : "";
+    const defaulted = parameter4.defaultValue === void 0 ? "" : ` = ${parameter4.defaultValue.text}`;
+    return `${parameter4.name}${nullability}${defaulted}`;
+  }).join(", ");
   return `${className}(${rendered})`;
 }
 function describeNameList(names) {
@@ -19781,6 +20012,7 @@ function push(diagnostics, uri, range2, code, message, related2 = []) {
 var init_project_source_settlement = __esm({
   "../packages/neoscript-language/src/project-source-settlement.ts"() {
     "use strict";
+    init_declared_constructors();
     init_project_source_construction_diagnostics();
     init_strict_compile_error();
     init_strict_parser();
@@ -21628,7 +21860,9 @@ function validateReferenceExpression(expression, expected, environment, uri, ran
   const typeArguments = expression.typeArguments ?? [];
   const names = expression.argumentNames ?? [];
   const idIndex = names.findIndex((name) => name === "id");
+  const provenanceIndex = names.findIndex((name) => name === "withProvenance");
   const hasId = idIndex >= 0;
+  const hasProvenance = provenanceIndex >= 0;
   const argument2 = expression.args[hasId ? idIndex : 0];
   const malformed = (message) => pushDiagnostic(
     diagnostics,
@@ -21672,9 +21906,11 @@ function validateReferenceExpression(expression, expected, environment, uri, ran
     }
     return;
   }
-  if (expression.args.length !== 1 || hasId && (idIndex !== 0 || names.some((name) => name !== "id")) || !hasId && names.some((name) => name !== null)) {
+  const validIdShape = hasId && idIndex === 0 && expression.args.length === (hasProvenance ? 2 : 1) && (!hasProvenance || provenanceIndex === 1) && names.every((name) => name === "id" || name === "withProvenance");
+  const validSymbolShape = !hasId && !hasProvenance && expression.args.length === 1 && names.every((name) => name === null);
+  if (!validIdShape && !validSymbolShape) {
     malformed(
-      "Reference requires exactly one symbol argument or one named id: string argument."
+      "Reference requires one symbol argument, or id: string followed by optional withProvenance: bool."
     );
     return;
   }
@@ -21684,6 +21920,10 @@ function validateReferenceExpression(expression, expected, environment, uri, ran
       malformed("Reference id must be one non-empty string literal.");
       return;
     }
+    if (hasProvenance && expression.args[provenanceIndex]?.kind !== "litBool") {
+      malformed("Reference withProvenance must be a boolean literal.");
+      return;
+    }
     if (!explicit && expected?.name !== "string") {
       malformed("Reference(id: ...) requires an explicit generic target type.");
       return;
@@ -24443,6 +24683,223 @@ var init_project_source_type_checker = __esm({
   }
 });
 
+// ../packages/neoscript-language/src/project-source-parameter-defaults.ts
+function validateProjectSourceParameterDefaults(documents) {
+  const diagnostics = [];
+  const enumOptions = collectEnumOptions(documents);
+  for (const [uri, document] of documents) {
+    for (const declaration of document.declarations) {
+      if (declaration.kind === "class") {
+        if (declaration.headerParameters !== void 0) {
+          validateParameterList(
+            uri,
+            declaration.headerParameters,
+            { deferred: false },
+            enumOptions,
+            diagnostics
+          );
+        }
+        for (const constructor2 of declaration.constructors) {
+          validateParameterList(
+            uri,
+            constructor2.parameters,
+            { deferred: false },
+            enumOptions,
+            diagnostics
+          );
+        }
+      }
+      if (declaration.kind === "class" || declaration.kind === "interface") {
+        for (const member of declaration.members) {
+          if (member.kind !== "function") continue;
+          validateParameterList(
+            uri,
+            member.parameters,
+            { deferred: member.modifiers.includes("async") },
+            enumOptions,
+            diagnostics
+          );
+        }
+      }
+    }
+  }
+  return diagnostics;
+}
+function collectEnumOptions(documents) {
+  const options = /* @__PURE__ */ new Map();
+  for (const document of documents.values()) {
+    for (const declaration of document.declarations) {
+      if (declaration.kind !== "enum") continue;
+      const names = options.get(declaration.name) ?? options.set(declaration.name, /* @__PURE__ */ new Set()).get(declaration.name);
+      for (const option of declaration.options) names.add(option.name);
+    }
+  }
+  return options;
+}
+function validateParameterList(uri, parameters, context, enumOptions, diagnostics) {
+  let lastNonDefaultedIndex = -1;
+  for (let index = parameters.length - 1; index >= 0; index -= 1) {
+    if (parameters[index].defaultValue === void 0) {
+      lastNonDefaultedIndex = index;
+      break;
+    }
+  }
+  parameters.forEach((parameter4, index) => {
+    const defaultValue = parameter4.defaultValue;
+    if (defaultValue === void 0) return;
+    if (context.deferred) {
+      diagnostics.push({
+        uri,
+        range: defaultValue.range,
+        severity: "error",
+        source: "neo-project",
+        code: PARAMETER_DEFAULT_ON_DEFERRED_FUNCTION,
+        message: `Parameter '${parameter4.name}' of a deferred function cannot declare a default: generated C# appends a trailing deferred-completion parameter, which a defaulted parameter may not precede.`
+      });
+    }
+    if (index < lastNonDefaultedIndex) {
+      diagnostics.push({
+        uri,
+        range: parameter4.range,
+        severity: "error",
+        source: "neo-project",
+        code: DEFAULT_BEFORE_REQUIRED_PARAMETER,
+        message: `Parameter '${parameter4.name}' declares a default before parameter '${parameters[lastNonDefaultedIndex].name}', which has none. Defaulted parameters must come after every non-defaulted parameter.`
+      });
+    }
+    validateDefaultExpression(
+      uri,
+      parameter4,
+      defaultValue,
+      enumOptions,
+      diagnostics
+    );
+  });
+}
+function validateDefaultExpression(uri, parameter4, defaultValue, enumOptions, diagnostics) {
+  const constant = classifyConstantDefault(defaultValue.text);
+  if (constant === null) {
+    diagnostics.push({
+      uri,
+      range: defaultValue.range,
+      severity: "error",
+      source: "neo-project",
+      code: NON_CONSTANT_PARAMETER_DEFAULT,
+      message: `Parameter '${parameter4.name}' default must be a constant: a bool, number, or string literal, a leading-dot enum option, or null.`
+    });
+    return;
+  }
+  const mismatch = defaultTypeMismatch(
+    parameter4.type,
+    constant,
+    enumOptions,
+    parameter4.name
+  );
+  if (mismatch === null) return;
+  diagnostics.push({
+    uri,
+    range: defaultValue.range,
+    severity: "error",
+    source: "neo-project",
+    code: PARAMETER_DEFAULT_TYPE_MISMATCH,
+    message: mismatch
+  });
+}
+function classifyConstantDefault(text) {
+  let expression;
+  try {
+    expression = parseExpression(text);
+  } catch {
+    return null;
+  }
+  return classifyConstantExpression(expression);
+}
+function classifyConstantExpression(expression) {
+  switch (expression.kind) {
+    case "litNull":
+      return { kind: "null" };
+    case "litBool":
+      return { kind: "bool" };
+    case "litInt":
+      return { kind: "int" };
+    case "litFloat":
+      return { kind: "float" };
+    case "litString":
+      return { kind: "string" };
+    case "contextualEnum":
+      return { kind: "enumOption", optionName: expression.name };
+    case "unary": {
+      if (expression.op !== "-") return null;
+      const operand = classifyConstantExpression(expression.operand);
+      if (operand === null) return null;
+      if (operand.kind !== "int" && operand.kind !== "float") return null;
+      return operand;
+    }
+    default:
+      return null;
+  }
+}
+function defaultTypeMismatch(type, constant, enumOptions, parameterName) {
+  if (constant.kind === "null") {
+    if (type.nullable) return null;
+    return `Parameter '${parameterName}' defaults to null, but its type '${formatSourceType(type)}' is not nullable.`;
+  }
+  const declaredEnumOptions = enumOptions.get(type.name);
+  if (constant.kind === "enumOption") {
+    if (declaredEnumOptions === void 0) {
+      return `Parameter '${parameterName}' defaults to enum option '.${constant.optionName}', but its type '${formatSourceType(type)}' is not an enum.`;
+    }
+    if (!declaredEnumOptions.has(constant.optionName)) {
+      return `Parameter '${parameterName}' defaults to '.${constant.optionName}', which enum '${type.name}' does not declare.`;
+    }
+    return null;
+  }
+  if (constantKindMatchesPrimitive(type.name, constant.kind)) return null;
+  if (PRIMITIVE_PARAMETER_TYPES.has(type.name) || declaredEnumOptions !== void 0) {
+    return `Parameter '${parameterName}' default is a ${describeConstant(constant)}, which does not match its declared type '${formatSourceType(type)}'.`;
+  }
+  return `Parameter '${parameterName}' of type '${formatSourceType(type)}' can only default to null${type.nullable ? "" : ", and only when the type is nullable"}.`;
+}
+function constantKindMatchesPrimitive(typeName, kind) {
+  if (typeName === "bool") return kind === "bool";
+  if (typeName === "int") return kind === "int";
+  if (typeName === "float") return kind === "int" || kind === "float";
+  if (typeName === "decimal") return kind === "int" || kind === "float";
+  if (typeName === "string") return kind === "string";
+  return false;
+}
+function describeConstant(constant) {
+  if (constant.kind === "bool") return "bool literal";
+  if (constant.kind === "string") return "string literal";
+  if (constant.kind === "int") return "whole-number literal";
+  return "fractional number literal";
+}
+function formatSourceType(type) {
+  const argumentsText = type.typeArguments.length === 0 ? "" : `<${type.typeArguments.map(formatSourceType).join(", ")}>`;
+  return `${type.name}${argumentsText}${type.nullable ? "?" : ""}`;
+}
+var PARAMETER_DEFAULT_DIAGNOSTIC_CODES, DEFAULT_BEFORE_REQUIRED_PARAMETER, PARAMETER_DEFAULT_TYPE_MISMATCH, NON_CONSTANT_PARAMETER_DEFAULT, PARAMETER_DEFAULT_ON_DEFERRED_FUNCTION, PRIMITIVE_PARAMETER_TYPES;
+var init_project_source_parameter_defaults = __esm({
+  "../packages/neoscript-language/src/project-source-parameter-defaults.ts"() {
+    "use strict";
+    init_language_spec();
+    init_strict_parser();
+    PARAMETER_DEFAULT_DIAGNOSTIC_CODES = {
+      defaultBeforeRequiredParameter: "default-before-required-parameter",
+      parameterDefaultTypeMismatch: "parameter-default-type-mismatch",
+      nonConstantParameterDefault: "non-constant-parameter-default",
+      parameterDefaultOnDeferredFunction: "parameter-default-on-deferred-function"
+    };
+    ({
+      defaultBeforeRequiredParameter: DEFAULT_BEFORE_REQUIRED_PARAMETER,
+      parameterDefaultTypeMismatch: PARAMETER_DEFAULT_TYPE_MISMATCH,
+      nonConstantParameterDefault: NON_CONSTANT_PARAMETER_DEFAULT,
+      parameterDefaultOnDeferredFunction: PARAMETER_DEFAULT_ON_DEFERRED_FUNCTION
+    } = PARAMETER_DEFAULT_DIAGNOSTIC_CODES);
+    PRIMITIVE_PARAMETER_TYPES = new Set(NEOSCRIPT_PRIMITIVE_TYPES);
+  }
+});
+
 // ../packages/neoscript-language/src/project-source-analysis.ts
 function isSystemReservedRecordId(id2) {
   if (id2 === null) return false;
@@ -24500,6 +24957,7 @@ function analyzeNeoProjectSources(inputs, parsedDocuments = /* @__PURE__ */ new
   validateSystemAnnotationAuthoring(documents, diagnostics);
   validateTypeReferences(documents, symbols, diagnostics);
   diagnostics.push(...validateProjectSourceTypes(documents));
+  diagnostics.push(...validateProjectSourceParameterDefaults(documents));
   diagnostics.push(...validateProjectSourceSettlement(documents));
   diagnostics.push(...validateProjectSourceSemantics(documents));
   const bodyCompilation = compileProjectSourceBodies(documents);
@@ -25108,6 +25566,7 @@ var init_project_source_analysis = __esm({
     init_project_source_settlement();
     init_project_source_script_compiler();
     init_project_source_type_checker();
+    init_project_source_parameter_defaults();
     BUILTIN_TYPE_NAMES = /* @__PURE__ */ new Set([
       ...NEOSCRIPT_PRIMITIVE_TYPES,
       ...NEOSCRIPT_BUILTIN_TYPES,
@@ -25427,7 +25886,9 @@ function projectCompletions(analysis, document, position) {
       items: constructorFields.map((field) => ({
         label: field.name,
         kind: "property",
-        detail: field.type,
+        // P65 §6. C#-style square brackets mark a defaulted parameter as
+        // omittable at the call site.
+        detail: field.defaultText === void 0 ? field.type : `[${field.type} = ${field.defaultText}]`,
         insertText: `${field.name}: `
       }))
     };
@@ -25862,7 +26323,11 @@ function declaredConstructorNamedArguments(analysis, typeName, used) {
   return [...fields.values()];
 }
 function parameterArgumentField(parameter4) {
-  return { name: parameter4.name, type: sourceTypeText(parameter4.type) };
+  return {
+    name: parameter4.name,
+    type: sourceTypeText(parameter4.type),
+    ...parameter4.defaultValue === void 0 ? {} : { defaultText: parameter4.defaultValue.text }
+  };
 }
 function projectInitializerMemberCompletions(analysis, document, position) {
   const site = constructionSiteAt(analysis, document, position);
@@ -25922,6 +26387,13 @@ function constructibleMembers(analysis, typeName) {
   }
   return [...members.values()];
 }
+function sourceParameterSignatureText(parameter4) {
+  return constructorParameterLabel(sourceParameterProjection(parameter4));
+}
+function functionParameterLabel(parameter4) {
+  const suffix = parameter4.defaultValue === void 0 ? "" : ` = ${parameter4.defaultValue.text}`;
+  return `${parameter4.type.name} ${parameter4.name}${suffix}`;
+}
 function sourceTypeText(type) {
   const args = type.typeArguments.length > 0 ? `<${type.typeArguments.map(sourceTypeText).join(", ")}>` : "";
   return `${type.name}${args}${type.nullable ? "?" : ""}`;
@@ -26048,7 +26520,7 @@ function projectConstructionContractMarkdown(analysis, className) {
   const contract = classConstructionContract(index, className);
   if (!contract) return "";
   if (contract.kind === "required") {
-    const parameters = contract.parameters.map((parameter4) => `${sourceTypeText(parameter4.type)} ${parameter4.name}`).join(", ");
+    const parameters = contract.parameters.map(sourceParameterSignatureText).join(", ");
     return `
 
 Construct with \`new(${parameters})\` \u2014 this class declares a required constructor, so the implicit \`new\` is unavailable.`;
@@ -26063,9 +26535,7 @@ Construct with \`new(${parameters})\` \u2014 this class declares a required cons
   }
   if (contract.kind === "declared") {
     const overloads = contract.constructors.map(
-      (constructor2) => `\`${className}(${constructor2.parameters.map(
-        (parameter4) => `${sourceTypeText(parameter4.type)} ${parameter4.name}`
-      ).join(", ")})\``
+      (constructor2) => `\`${className}(${constructor2.parameters.map(sourceParameterSignatureText).join(", ")})\``
     ).join(", ");
     lines.push(`Constructors: ${overloads}.`);
   }
@@ -26160,7 +26630,11 @@ function projectSignatureHelp(analysis, document, position) {
     return signatureResult(`@${callee.text}`, parameters, activeParameter);
   }
   if (callee.text === "Reference") {
-    return signatureResult("Reference", ["symbol", "id"], activeParameter);
+    return signatureResult(
+      "Reference",
+      ["symbol or id", "withProvenance = false"],
+      activeParameter
+    );
   }
   if (callee.text === "Pause") {
     return signatureResult(
@@ -26187,13 +26661,11 @@ function projectSignatureHelp(analysis, document, position) {
   if (functions.length === 0) return null;
   return {
     signatures: functions.map(({ owner, member }) => {
-      const parameters = member.parameters.map(
-        (parameter4) => `${parameter4.type.name} ${parameter4.name}`
-      );
+      const parameters = member.parameters.map(functionParameterLabel);
       return {
         label: `${member.type.name} ${owner}.${member.name}(${parameters.join(", ")})`,
         parameters: member.parameters.map((parameter4) => ({
-          label: `${parameter4.type.name} ${parameter4.name}`
+          label: functionParameterLabel(parameter4)
         }))
       };
     }),
@@ -26959,7 +27431,10 @@ function findTypeDeclaration(analysis, name) {
   return void 0;
 }
 function constructorParameterLabel(parameter4) {
-  return `${parameter4.type} ${parameter4.name}`;
+  return `${parameter4.type} ${parameter4.name}${parameterDefaultSuffix2(parameter4)}`;
+}
+function parameterDefaultSuffix2(parameter4) {
+  return parameter4.defaultText === void 0 ? "" : ` = ${parameter4.defaultText}`;
 }
 function projectConstructorTypeName(analysis, document, callee, beforeCallee) {
   if (beforeCallee?.text === "new") return callee.text;
@@ -26985,7 +27460,11 @@ function declarationConstructorParameters(declaration) {
   ).map((member) => ({ type: member.type.name, name: member.name }));
 }
 function sourceParameterProjection(parameter4) {
-  return { type: sourceTypeText(parameter4.type), name: parameter4.name };
+  return {
+    type: sourceTypeText(parameter4.type),
+    name: parameter4.name,
+    ...parameter4.defaultValue === void 0 ? {} : { defaultText: parameter4.defaultValue.text }
+  };
 }
 function graphConstructorParameters(typeName) {
   switch (typeName) {
@@ -27104,6 +27583,9 @@ function projectConstructionQuickFixes(analysis, document, diagnostic) {
   if (diagnostic.code === "unknown-identifier") {
     return moveParametersToClassHeaderFixes(analysis, document, diagnostic);
   }
+  if (diagnostic.code === "default-before-required-parameter") {
+    return moveDefaultedParameterFixes(analysis, document, diagnostic);
+  }
   return [];
 }
 function settleRequiredMemberFixes(analysis, document, diagnostic) {
@@ -27209,10 +27691,13 @@ function placeholderValue(analysis, index, type, depth) {
   if (declaration.modifiers.includes("abstract")) return null;
   const contract = classConstructionContract(index, type.name);
   if (contract?.kind !== "required") return "new()";
-  if (contract.parameters.length === 0) return "new()";
+  const mandatory = contract.parameters.filter(
+    (parameter4) => parameter4.defaultValue === void 0
+  );
+  if (mandatory.length === 0) return "new()";
   if (depth > 0) return null;
   const args = [];
-  for (const parameter4 of contract.parameters) {
+  for (const parameter4 of mandatory) {
     const value = placeholderValue(analysis, index, parameter4.type, depth + 1);
     if (value === null) return null;
     args.push(`${parameter4.name}: ${value}`);
@@ -27404,6 +27889,71 @@ function innerBodyText(constructor2) {
   const trimmed = constructor2.body.text.trim();
   return trimmed.startsWith("{") && trimmed.endsWith("}") ? trimmed.slice(1, -1) : trimmed;
 }
+function moveDefaultedParameterFixes(analysis, document, diagnostic) {
+  const source = analysis.documents.get(document.uri);
+  if (!source) return [];
+  const parameters = parameterListAt(source.declarations, diagnostic.range);
+  if (parameters === null) return [];
+  const first = parameters[0];
+  const last = parameters[parameters.length - 1];
+  if (!first || !last) return [];
+  const text = new SourceText(document.text);
+  const authored = (parameter4) => text.text.slice(
+    text.offsetAt(parameter4.range.start),
+    text.offsetAt(parameter4.range.end)
+  );
+  const reordered = [
+    ...parameters.filter((parameter4) => parameter4.defaultValue === void 0),
+    ...parameters.filter((parameter4) => parameter4.defaultValue !== void 0)
+  ];
+  return [
+    {
+      title: "Move defaulted parameters after required parameters",
+      kind: "quickfix",
+      diagnostics: [diagnostic],
+      edit: {
+        changes: {
+          [document.uri]: [
+            {
+              range: {
+                start: first.range.start,
+                end: last.range.end
+              },
+              newText: reordered.map(authored).join(", ")
+            }
+          ]
+        }
+      },
+      preferred: true
+    }
+  ];
+}
+function parameterListAt(declarations, range2) {
+  for (const declaration of declarations) {
+    if (declaration.kind !== "class" && declaration.kind !== "interface") {
+      continue;
+    }
+    const lists = [];
+    if (declaration.kind === "class") {
+      if (declaration.headerParameters !== void 0) {
+        lists.push(declaration.headerParameters);
+      }
+      for (const constructor2 of declaration.constructors) {
+        lists.push(constructor2.parameters);
+      }
+    }
+    for (const member of declaration.members) {
+      if (member.kind === "function") lists.push(member.parameters);
+    }
+    for (const list of lists) {
+      const hit = list.some(
+        (parameter4) => rangeContains(parameter4.range, range2.start)
+      );
+      if (hit) return list;
+    }
+  }
+  return null;
+}
 var NEW_CONSTRUCTIBLE_BUILTIN_TYPES;
 var init_project_source_construction_quick_fixes = __esm({
   "../packages/neoscript-language/src/project-source-construction-quick-fixes.ts"() {
@@ -27560,6 +28110,7 @@ function manifestParameter(uri, parameter4) {
     name: parameter4.name,
     type: manifestType(parameter4.type),
     annotations: manifestAnnotations(parameter4.annotations),
+    default: parameter4.defaultValue?.text ?? null,
     source: { uri, range: parameter4.range }
   };
 }
@@ -27970,12 +28521,21 @@ function assertBaseClauseArguments(value, path) {
 }
 function assertParameter(value, path) {
   const parameter4 = record(value, path);
-  exactKeys(parameter4, path, ["name", "type", "annotations", "source"]);
+  exactKeys(parameter4, path, [
+    "name",
+    "type",
+    "annotations",
+    "default",
+    "source"
+  ]);
   string(parameter4.name, `${path}.name`);
   assertType(parameter4.type, `${path}.type`);
   array(parameter4.annotations, `${path}.annotations`).forEach(
     (annotation2, index) => assertAnnotation(annotation2, `${path}.annotations[${index}]`)
   );
+  if (parameter4.default !== null) {
+    string(parameter4.default, `${path}.default`);
+  }
   assertLocation(parameter4.source, `${path}.source`);
 }
 function assertMember(value, path) {
@@ -28408,6 +28968,7 @@ function projectSchemaManifest(input, options = {}) {
     members: memberById,
     classes: schemaClassById,
     interfaces: interfaceById,
+    enums: indexById(enums, "ProjectSchemaManifest.enums"),
     genericNames,
     effectiveWritabilityByMemberId: effectiveMemberWritability(
       members,
@@ -28469,7 +29030,8 @@ function groupDeclaredConstructors(declaredConstructors2, environment) {
         (parameter4) => ({
           name: parameter4.name,
           type: parameter4.type,
-          required: parameter4.type.nullable !== true
+          required: parameter4.type.nullable !== true,
+          ...parameter4.defaultValue === void 0 ? {} : { defaultValue: parameter4.defaultValue }
         })
       ),
       ...documentation === void 0 ? {} : { documentation },
@@ -29479,6 +30041,11 @@ function argumentsList(value, environment, field) {
       environment,
       `${field}.arguments[${index}].type`
     ),
+    ...manifestParameterDefault(
+      argument2,
+      environment,
+      `${field}.arguments[${index}]`
+    ),
     ...spanAndSelectionLocations(
       argument2.source,
       argument2.selectionSpan ?? argument2.source,
@@ -29487,6 +30054,54 @@ function argumentsList(value, environment, field) {
     )
   }));
 }
+function neoScriptParameterDefaultDisplayText(options) {
+  const { value, kind } = options;
+  if (value === null) return "null";
+  if (kind === "enum") return `.${options.enumOptionName ?? String(value)}`;
+  if (kind === "decimal" && typeof value === "string") return value;
+  if (typeof value === "string") return JSON.stringify(value);
+  return String(value);
+}
+function manifestParameterDefault(argument2, environment, field) {
+  const declared = optionalRecord(argument2.default);
+  if (declared === void 0) return {};
+  const value = constantDefaultValue(declared.value, `${field}.default.value`);
+  const type = record2(argument2.type, `${field}.type`);
+  const kind = string2(type.kind, `${field}.type.kind`);
+  const enumOptionName = kind === "enum" && typeof value === "string" ? manifestEnumOptionName(
+    string2(type.enumId, `${field}.type.enumId`),
+    value,
+    environment
+  ) : void 0;
+  return {
+    defaultValue: {
+      displayText: neoScriptParameterDefaultDisplayText({
+        value,
+        kind: kind === "enum" || kind === "decimal" ? kind : "other",
+        ...enumOptionName === void 0 ? {} : { enumOptionName }
+      }),
+      value
+    }
+  };
+}
+function constantDefaultValue(value, field) {
+  if (value !== null && typeof value !== "boolean" && typeof value !== "number" && typeof value !== "string") {
+    throw new Error(
+      `${field} must be a \xA71.2 constant (boolean, number, string, or null), received ${JSON.stringify(value)}.`
+    );
+  }
+  return value;
+}
+function manifestEnumOptionName(enumId, optionId, environment) {
+  const schemaEnum = environment.enums.get(enumId);
+  if (schemaEnum === void 0) return void 0;
+  const options = records(schemaEnum.options ?? [], `enum ${enumId}.options`);
+  const option = options.find(
+    (candidate) => candidate.id === optionId || candidate.key === optionId
+  );
+  if (option === void 0) return void 0;
+  return typeof option.name === "string" ? option.name : void 0;
+}
 function sourceLocation(value, environment, field) {
   const source = optionalRecord(value);
   if (!source) return {};
@@ -30436,6 +31051,7 @@ var init_src = __esm({
     init_project_source_construction_diagnostics();
     init_project_source_construction_quick_fixes();
     init_project_source_manifest();
+    init_project_source_parameter_defaults();
     init_project_source_settlement();
     init_project_source_parser();
     init_project_source_script_compiler();
@@ -32401,10 +33017,7 @@ function memberToDocumentFields(member, baseData3) {
   }
   if (member.kind === "function" || member.kind === "scriptFunction") {
     fields.returnTypeInfo = manifestReturnTypeToDocument(member.returnType);
-    fields.argumentTypes = member.arguments.map((argument2) => ({
-      name: argument2.name,
-      ...manifestTypeToDocument(argument2.type)
-    }));
+    fields.argumentTypes = member.arguments.map(manifestArgumentToDocument);
     fields.deferred = member.deferred;
     if (member.kind === "scriptFunction" && member.script !== null && member.bodyMode !== "ui") {
       fields.code = member.script.sourceText;
@@ -32416,16 +33029,10 @@ function memberToDocumentFields(member, baseData3) {
   }
   if (member.kind === "delegate") {
     fields.returnTypeInfo = manifestReturnTypeToDocument(member.returnType);
-    fields.argumentTypes = member.arguments.map((argument2) => ({
-      name: argument2.name,
-      ...manifestTypeToDocument(argument2.type)
-    }));
+    fields.argumentTypes = member.arguments.map(manifestArgumentToDocument);
   }
   if (member.kind === "action") {
-    fields.argumentTypes = member.arguments.map((argument2) => ({
-      name: argument2.name,
-      ...manifestTypeToDocument(argument2.type)
-    }));
+    fields.argumentTypes = member.arguments.map(manifestArgumentToDocument);
   }
   if (member.kind === "generic") {
     fields.genericParamId = member.genericParamId;
@@ -32515,11 +33122,25 @@ function documentArgumentsToManifest(value, record3, source) {
         `argumentTypes[${index}].name`
       ),
       type: documentTypeToManifest(argument2, record3, `argumentTypes[${index}]`),
+      default: documentParameterDefaultToManifest(
+        argument2.defaultValue,
+        record3,
+        `argumentTypes[${index}].defaultValue`,
+        source
+      ),
       source,
       selectionSpan: source
     };
   });
 }
+function documentParameterDefaultToManifest(value, record3, path, source) {
+  if (value === void 0 || value === null) return null;
+  const wrapper = requireRecordValue(value, record3, path);
+  if (!Object.hasOwn(wrapper, "value")) {
+    throw invalidDocument(record3, path, 'must carry a "value" key');
+  }
+  return { value: wrapper.value, source };
+}
 function optionalDocumentType(value, record3, path) {
   if (value === null || value === void 0) return null;
   return documentTypeToManifest(value, record3, path);
@@ -32668,6 +33289,13 @@ function documentTypeToManifest(value, record3, path) {
     `unsupported type-info discriminator ${kind}`
   );
 }
+function manifestArgumentToDocument(argument2) {
+  return {
+    name: argument2.name,
+    ...manifestTypeToDocument(argument2.type),
+    ...argument2.default === null ? {} : { defaultValue: { value: argument2.default.value } }
+  };
+}
 function manifestReturnTypeToDocument(type) {
   if (type.kind === "void") return { type: "Void", required: true };
   return manifestTypeToDocument(type);
@@ -33407,10 +34035,7 @@ function interfaceToDocument(neoInterface) {
         kind: "function",
         ...member.docsText === void 0 ? {} : { docsText: member.docsText },
         returnTypeInfo: manifestReturnTypeToDocument(member.returnType),
-        argumentTypes: member.arguments.map((argument2) => ({
-          name: argument2.name,
-          ...manifestTypeToDocument(argument2.type)
-        })),
+        argumentTypes: member.arguments.map(manifestArgumentToDocument),
         deferred: member.deferred,
         accessModifierKind: member.accessModifier
       };
@@ -33909,10 +34534,7 @@ function constructorToDocument(declared) {
   return omitUndefined({
     id: declared.id,
     classId: declared.classId,
-    argumentTypes: declared.arguments.map((argument2) => ({
-      name: argument2.name,
-      ...manifestTypeToDocument(argument2.type)
-    })),
+    argumentTypes: declared.arguments.map(manifestArgumentToDocument),
     code: declared.code,
     baseArguments: declared.baseArguments,
     baseInitializerFields: declared.baseInitializerFields,
@@ -35568,14 +36190,22 @@ function assertFunctionArgument(value, path) {
   const argument2 = objectAt(value, path, [
     "name",
     "type",
+    "default",
     "source",
     "selectionSpan"
   ]);
   nonEmptyString(argument2.name, `${path}.name`);
   assertType2(argument2.type, `${path}.type`);
+  assertParameterDefault(argument2.default, `${path}.default`);
   assertSpan(argument2.source, `${path}.source`);
   assertSpan(argument2.selectionSpan, `${path}.selectionSpan`);
 }
+function assertParameterDefault(value, path) {
+  if (value === null) return;
+  const parameterDefault = objectAt(value, path, ["value", "source"]);
+  assertJsonValue(parameterDefault.value, `${path}.value`, 0);
+  assertSpan(parameterDefault.source, `${path}.source`);
+}
 function assertAbstractScriptInvariant(value, path) {
   const isAbstract = value.modifier === "abstract" || value.modifier === "abstractOverride";
   const hasUiBody = value.bodyMode === "ui" && value.uiAction !== void 0;
@@ -37789,7 +38419,30 @@ function isNSFunctionReturnTypeInfo(value) {
   return isNSTypeInfo(value) || isNSTypeInfoVoid(value);
 }
 function isNSFunctionArgumentTypeInfo(value) {
-  return isNSArgumentTypeInfo(value) && !typeInfoContainsUnknown(value, /* @__PURE__ */ new Set());
+  return isNSArgumentTypeInfo(value) && !typeInfoContainsUnknown(value, /* @__PURE__ */ new Set()) && hasValidParameterDefault(value);
+}
+function hasValidParameterDefault(value) {
+  const wrapper = value.defaultValue;
+  if (wrapper === void 0) return true;
+  if (typeof wrapper !== "object" || wrapper === null) return false;
+  const keys = Object.keys(wrapper);
+  if (keys.length !== 1 || keys[0] !== "value") return false;
+  const payload = wrapper.value;
+  if (payload === null) return !value.required;
+  switch (value.type) {
+    case 1 /* Bool */:
+      return typeof payload === "boolean";
+    case 2 /* Int */:
+      return typeof payload === "number" && Number.isInteger(payload);
+    case 4 /* Float */:
+      return typeof payload === "number" && Number.isFinite(payload);
+    case 20 /* Decimal */:
+    case 3 /* String */:
+    case 8 /* Enum */:
+      return typeof payload === "string";
+    default:
+      return false;
+  }
 }
 function typeInfoContainsUnknown(value, ancestors) {
   if (value.type === NS_TYPE_UNKNOWN) return true;
@@ -37840,7 +38493,9 @@ function isNSKeyOf(value) {
 }
 function isNSPointerReference(value) {
   const v = value;
-  return v?.type === "reference" /* reference */ && typeof v?.valueId === "string";
+  if (v?.type !== "reference" /* reference */) return false;
+  if (typeof v.valueId !== "string") return false;
+  return v.withProvenance === void 0 || typeof v.withProvenance === "boolean";
 }
 function isNSPointerVariable(value) {
   const v = value;
@@ -38590,6 +39245,51 @@ var init_neoscript_guards = __esm({
   }
 });
 
+// ../src/models/neoscript/parameter-defaults.ts
+function parameterHasDefault(argument2) {
+  return argument2.defaultValue !== void 0;
+}
+function hasAnyParameterDefault(argumentTypes) {
+  return argumentTypes.some(parameterHasDefault);
+}
+function validateParameterDefaults(argumentTypes) {
+  const violations = [];
+  let lastNonDefaultedIndex = -1;
+  for (let index = argumentTypes.length - 1; index >= 0; index -= 1) {
+    const argument2 = argumentTypes[index];
+    if (argument2 !== void 0 && !parameterHasDefault(argument2)) {
+      lastNonDefaultedIndex = index;
+      break;
+    }
+  }
+  for (let index = 0; index < argumentTypes.length; index += 1) {
+    const argument2 = argumentTypes[index];
+    if (argument2 === void 0) continue;
+    const defaultValue = argument2.defaultValue;
+    if (defaultValue === void 0) continue;
+    if (index < lastNonDefaultedIndex) {
+      violations.push({
+        code: "default-before-required-parameter",
+        index,
+        name: argument2.name
+      });
+    }
+    if (defaultValue.value === null && argument2.required) {
+      violations.push({
+        code: "parameter-default-type-mismatch",
+        index,
+        name: argument2.name
+      });
+    }
+  }
+  return violations;
+}
+var init_parameter_defaults = __esm({
+  "../src/models/neoscript/parameter-defaults.ts"() {
+    "use strict";
+  }
+});
+
 // ../src/models/interfaces/interface-graph.ts
 function resolveInterfaceClosure(interfaceId, interfaces) {
   const byId = new Map(
@@ -38726,6 +39426,7 @@ var init_neoscript = __esm({
     "use strict";
     init_neoscript_types();
     init_neoscript_guards();
+    init_parameter_defaults();
     init_type_info_compatibility();
   }
 });
@@ -39384,14 +40085,20 @@ function isMemberFunctionBase(value) {
   if (!Array.isArray(v.argumentTypes)) return false;
   if (typeof v.deferred !== "boolean") return false;
   const names = /* @__PURE__ */ new Set();
+  const argumentTypes = [];
   for (const arg of v.argumentTypes) {
     if (!isNSFunctionArgumentTypeInfo(arg)) return false;
     if (!isValidCallableIdentifier(arg.name)) return false;
     if (arg.type === NS_TYPE_UNKNOWN) return false;
     if (names.has(arg.name)) return false;
     names.add(arg.name);
+    argumentTypes.push(arg);
   }
-  return true;
+  return hasValidParameterDefaults(argumentTypes, v.deferred);
+}
+function hasValidParameterDefaults(argumentTypes, deferred) {
+  if (deferred && hasAnyParameterDefault(argumentTypes)) return false;
+  return validateParameterDefaults(argumentTypes).length === 0;
 }
 function normalizedCompiledFunctionReturnType(typeInfo) {
   if (typeInfo.type === NS_TYPE_VOID) {
@@ -39439,6 +40146,7 @@ function isMemberNSFunctionBase(value) {
   if (v.action !== void 0 && v.action !== null) return false;
   if (v.bodyMode !== void 0 && v.bodyMode !== "ui") return false;
   const names = /* @__PURE__ */ new Set();
+  const argumentTypes = [];
   for (const argument2 of v.argumentTypes) {
     if (!isNSFunctionArgumentTypeInfo(argument2)) return false;
     if (argument2.type === NS_TYPE_UNKNOWN) return false;
@@ -39446,7 +40154,9 @@ function isMemberNSFunctionBase(value) {
     if (NSFunctionArgumentReservedNames.has(argument2.name)) return false;
     if (names.has(argument2.name)) return false;
     names.add(argument2.name);
+    argumentTypes.push(argument2);
   }
+  if (!hasValidParameterDefaults(argumentTypes, v.deferred)) return false;
   if (v.isAbstract === true) {
     if (v.bodyMode !== void 0) return false;
     if (v.uiAction !== void 0 && v.uiAction !== null) return false;
@@ -39523,6 +40233,7 @@ function isMemberDelegateBase(value) {
     if (argument2.type === NS_TYPE_UNKNOWN) return false;
     if (names.has(argument2.name)) return false;
     names.add(argument2.name);
+    if (argument2.defaultValue !== void 0) return false;
   }
   const defaultValue = v.defaultValue;
   if (defaultValue === void 0 || defaultValue === null) return true;
@@ -39561,6 +40272,7 @@ function isMemberActionBase(value) {
     if (argument2.type === NS_TYPE_UNKNOWN) return false;
     if (names.has(argument2.name)) return false;
     names.add(argument2.name);
+    if (argument2.defaultValue !== void 0) return false;
   }
   const defaultValue = v.defaultValue;
   if (defaultValue === void 0 || defaultValue === null) return true;
@@ -39792,6 +40504,7 @@ function isMemberOverrideBase(value) {
   if (v.argumentTypes !== void 0) {
     if (!Array.isArray(v.argumentTypes)) return false;
     if (!v.argumentTypes.every(isNSFunctionArgumentTypeInfo)) return false;
+    if (hasAnyParameterDefault(v.argumentTypes)) return false;
   }
   if (v.deferred !== void 0 && typeof v.deferred !== "boolean") {
     return false;
@@ -43670,7 +44383,11 @@ function isNeoInterfaceMember(value) {
     if (!isNSFunctionArgumentTypeInfo(argumentType)) return false;
     if (containsForbiddenMemberTypeInfo(argumentType)) return false;
   }
-  return typeof member.deferred === "boolean";
+  if (typeof member.deferred !== "boolean") return false;
+  if (member.deferred && hasAnyParameterDefault(member.argumentTypes)) {
+    return false;
+  }
+  return validateParameterDefaults(member.argumentTypes).length === 0;
 }
 function isInterfaceMembersRecord(value) {
   if (typeof value !== "object") return false;
@@ -43738,6 +44455,7 @@ var init_interface_types = __esm({
     init_neoscript_types();
     init_docs_text2();
     init_neoscript_guards();
+    init_parameter_defaults();
     init_member_kinds();
   }
 });
@@ -46056,11 +46774,46 @@ function baseConstruction(requiredConstructor) {
 function renderHeaderParameters(context, requiredConstructor) {
   if (requiredConstructor === void 0) return "";
   const parameters = requiredConstructor.arguments.map(
-    (argument2) => `${renderType(context, argument2.type)} ${argument2.name}`
+    (argument2) => renderParameter(context, argument2)
   );
   if (parameters.length === 0 && requiredConstructor.code !== null) return "";
   return `(${parameters.join(", ")})`;
 }
+function renderParameter(context, argument2) {
+  const declaration = `${renderType(context, argument2.type)} ${argument2.name}`;
+  if (argument2.default === null) return declaration;
+  return `${declaration} = ${renderParameterDefault(context, argument2)}`;
+}
+function renderParameterDefault(context, argument2) {
+  const value = argument2.default?.value;
+  if (value === null || value === void 0) return "null";
+  if (argument2.type.kind === "enum") {
+    if (typeof value !== "string") {
+      throw new Error(
+        `Parameter ${argument2.name} stores an enum default that is not an option id.`
+      );
+    }
+    const schemaEnum = required(context.enums, argument2.type.enumId, "enum");
+    const option = schemaEnum.options.find(
+      (candidate) => candidate.id === value || candidate.key === value
+    );
+    if (option === void 0) {
+      throw new Error(
+        `Parameter ${argument2.name} defaults to option id ${quote(value)}, which its enum does not declare. Emitting it as null would delete the default on the next push.`
+      );
+    }
+    return `.${option.name}`;
+  }
+  if (argument2.type.kind === "decimal" && typeof value === "string") {
+    return value;
+  }
+  if (typeof value === "string") return quote(value);
+  if (typeof value === "number") return formatNeoNumber(value);
+  if (typeof value === "boolean") return String(value);
+  throw new Error(
+    `Parameter ${argument2.name} stores a default that is not a constant value.`
+  );
+}
 function emitInitBlock(code) {
   if (code.trim().length === 0) return "init {\n}";
   return `init {
@@ -46075,7 +46828,7 @@ function emitConstructor(context, schemaClass2, declared) {
     ...docsTextLines(declared.docsText),
     id(declared.id).trimEnd()
   ];
-  const parameters = declared.arguments.map((argument2) => `${renderType(context, argument2.type)} ${argument2.name}`).join(", ");
+  const parameters = declared.arguments.map((argument2) => renderParameter(context, argument2)).join(", ");
   const baseClause = declared.baseArguments === void 0 || declared.baseArguments.length === 0 ? "" : `
   : base(${declared.baseArguments.map((argument2) => `${argument2.name}: ${argument2.code}`).join(", ")})`;
   const code = declared.code ?? "";
@@ -46145,9 +46898,7 @@ function emitInterface(context, value) {
       return `${emitDocsText(member.docsText)}${id(member.id)}${access}${renderType(context, member.type)} ${member.name} { get;${member.settable ? " set;" : ""} }`;
     }
     const deferred = member.deferred ? "async " : "";
-    return `${emitDocsText(member.docsText)}${id(member.id)}${access}${deferred}${renderReturnType(context, member.returnType)} ${member.name}(${member.arguments.map(
-      (argument2) => `${renderType(context, argument2.type)} ${argument2.name}`
-    ).join(", ")});`;
+    return `${emitDocsText(member.docsText)}${id(member.id)}${access}${deferred}${renderReturnType(context, member.returnType)} ${member.name}(${member.arguments.map((argument2) => renderParameter(context, argument2)).join(", ")});`;
   });
   return `${emitDocsText(value.docsText)}${id(value.id)}interface ${value.name}${bases.length ? ` : ${bases.join(", ")}` : ""} {
 ${members.map((member) => indentNeoSourceNonEmptyLines(member, 2)).join("\n\n")}
@@ -46195,9 +46946,7 @@ ${indentNeoSourceNonEmptyLines(setter, 4)}
 ${prefix}${renderType(context, member.returnType)} ${member.name}${body}`;
   }
   if (member.kind === "function" || member.kind === "scriptFunction") {
-    const signature = `${prefix}${member.deferred ? "async " : ""}${renderReturnType(context, member.returnType)} ${member.name}(${member.arguments.map(
-      (argument2) => `${renderType(context, argument2.type)} ${argument2.name}`
-    ).join(", ")})`;
+    const signature = `${prefix}${member.deferred ? "async " : ""}${renderReturnType(context, member.returnType)} ${member.name}(${member.arguments.map((argument2) => renderParameter(context, argument2)).join(", ")})`;
     const tracked = member.kind === "scriptFunction" ? member.script?.sourceText ?? uiFunctionSource(context, member) : null;
     const body = tracked === null ? null : emitFunctionBody(tracked);
     const abstractContract = member.modifier === "abstract" || member.modifier === "abstractOverride";
@@ -50592,9 +51341,14 @@ function collectFunctions(args) {
       for (const action of node.actions) {
         if (!isObjectRecord2(action) || action.type !== 0 || !isObjectRecord2(action.logic))
           continue;
-        if (action.logic.sourceInline === true || action.logic.type === 0 && isCompleteUIAction(action.logic.action))
-          continue;
         const useId = stringField(action, "id");
+        if (action.logic.sourceInline === true) continue;
+        if (action.logic.type === 0) {
+          if (isCompleteUIAction(action.logic.action)) continue;
+          throw new Error(
+            `Dialogue action "${useId}" on actions node "${nodeId}" is incomplete. Complete or remove the action in Neo Compose before pulling.`
+          );
+        }
         add(action.logic, `action:${useId}`, "void");
       }
     }
@@ -51280,13 +52034,13 @@ function withPersistedConstructorSignatures(index, classes, constructors) {
       if (required2 !== void 0) {
         persistedRequiredByClassName.set(
           schemaClass2.name,
-          required2.arguments.map((argument2) => argument2.name)
+          required2.arguments.map(persistedParameter)
         );
       }
     }
     const overloads = (schemaClass2.constructorIds ?? []).flatMap((id2) => {
       const constructor2 = byId.get(id2);
-      return constructor2 === void 0 ? [] : [constructor2.arguments.map((argument2) => argument2.name)];
+      return constructor2 === void 0 ? [] : [constructor2.arguments.map(persistedParameter)];
     });
     if (overloads.length > 0) {
       persistedByClassName.set(schemaClass2.name, overloads);
@@ -51298,6 +52052,10 @@ function withPersistedConstructorSignatures(index, classes, constructors) {
     persistedRequiredByClassName
   };
 }
+function persistedParameter(argument2) {
+  const hasDefault = argument2.default !== null && argument2.default !== void 0;
+  return { name: argument2.name, defaulted: hasDefault };
+}
 function declaresConstructors(index, className) {
   if (className === null) return false;
   if (index.requiredByClassName.has(className)) return true;
@@ -51307,16 +52065,24 @@ function declaresConstructors(index, className) {
 function declaresParameterlessConstructor(index, className) {
   if (className === null) return false;
   const required2 = index.requiredByClassName.get(className);
-  if (required2 !== void 0 && required2.parameters.length === 0) return true;
+  if (required2 !== void 0 && manifestListIsCallableBare(required2.parameters)) {
+    return true;
+  }
   const persistedRequired = index.persistedRequiredByClassName.get(className);
-  if (persistedRequired !== void 0 && persistedRequired.length === 0) {
+  if (persistedRequired !== void 0 && persistedListIsCallableBare(persistedRequired)) {
     return true;
   }
   const declared = index.byClassName.get(className);
-  if (declared?.some((entry) => entry.parameters.length === 0) === true) {
+  if (declared?.some((entry) => manifestListIsCallableBare(entry.parameters)) === true) {
     return true;
   }
-  return index.persistedByClassName.get(className)?.some((parameters) => parameters.length === 0) ?? false;
+  return index.persistedByClassName.get(className)?.some(persistedListIsCallableBare) ?? false;
+}
+function manifestListIsCallableBare(parameters) {
+  return parameters.every((parameter4) => parameter4.default !== null);
+}
+function persistedListIsCallableBare(parameters) {
+  return parameters.every((parameter4) => parameter4.defaulted);
 }
 function initializerRequiresEvaluation(index, expression, targetClassName, runtimeIdentifiers = /* @__PURE__ */ new Set()) {
   if (expression.kind === "annotated") {
@@ -51346,7 +52112,11 @@ function requiredConstructorParameterNames(index, className) {
   if (required2 !== void 0) {
     return new Set(required2.parameters.map((parameter4) => parameter4.name));
   }
-  return new Set(index.persistedRequiredByClassName.get(className) ?? []);
+  return new Set(
+    (index.persistedRequiredByClassName.get(className) ?? []).map(
+      (parameter4) => parameter4.name
+    )
+  );
 }
 function expressionReadsRuntimeIdentifier(expression, runtimeIdentifiers) {
   if (runtimeIdentifiers.size === 0) return false;
@@ -51438,7 +52208,8 @@ function validateDeclaredConstructorOverloads(declaration) {
       id: declared.id ?? `${declaration.name}#${String(index)}`,
       parameters: declared.parameters.map((parameter4) => ({
         name: parameter4.name,
-        typeKey: positionalTypeKey(parameter4.type)
+        typeKey: positionalTypeKey(parameter4.type),
+        defaulted: parameter4.default !== null
       }))
     }))
   ).map((error) => ({
@@ -51464,6 +52235,102 @@ var init_declared_constructors2 = __esm({
   }
 });
 
+// src/project-source/lower-parameter-defaults.ts
+function lowerParameterDefault(context, parameter4, loweredType, path) {
+  if (parameter4.default === null) return null;
+  const expression = parseExpression(parameter4.default);
+  return {
+    value: lowerParameterDefaultValue(context, expression, loweredType, path),
+    source: span({ source: parameter4.source })
+  };
+}
+function lowerParameterDefaultValue(context, expression, type, path) {
+  switch (expression.kind) {
+    case "litNull":
+      if (!type.nullable) {
+        throw new Error(
+          `Parameter ${path} defaults to null, but its type is not nullable.`
+        );
+      }
+      return null;
+    case "litBool":
+      if (type.kind !== "bool") {
+        throw new Error(
+          `Parameter ${path} defaults to a bool literal, but its type is ${type.kind}.`
+        );
+      }
+      return expression.value;
+    case "litString":
+      if (type.kind !== "string") {
+        throw new Error(
+          `Parameter ${path} defaults to a string literal, but its type is ${type.kind}.`
+        );
+      }
+      return expression.value;
+    case "litInt":
+      if (type.kind === "decimal") return expression.raw;
+      if (type.kind !== "int" && type.kind !== "float") {
+        throw new Error(
+          `Parameter ${path} defaults to a number literal, but its type is ${type.kind}.`
+        );
+      }
+      return expression.value;
+    case "litFloat":
+      if (type.kind === "decimal") return expression.raw;
+      if (type.kind !== "float") {
+        throw new Error(
+          `Parameter ${path} defaults to a fractional literal, but its type is ${type.kind}.`
+        );
+      }
+      return expression.value;
+    case "unary": {
+      if (expression.op !== "-") {
+        throw new Error(
+          `Parameter ${path} default uses unary ${JSON.stringify(expression.op)}, which is not a constant spelling.`
+        );
+      }
+      const operand = lowerParameterDefaultValue(
+        context,
+        expression.operand,
+        type,
+        path
+      );
+      if (typeof operand === "number") return -operand;
+      if (type.kind === "decimal" && typeof operand === "string") {
+        return operand.startsWith("-") ? operand.slice(1) : `-${operand}`;
+      }
+      throw new Error(
+        `Parameter ${path} default applies unary minus to a non-numeric literal.`
+      );
+    }
+    case "contextualEnum": {
+      if (type.kind !== "enum") {
+        throw new Error(
+          `Parameter ${path} defaults to enum option .${expression.name}, but its type is ${type.kind}.`
+        );
+      }
+      const optionId = context.enumOptionsByName.get(type.enumId)?.get(expression.name);
+      if (optionId === void 0) {
+        throw new Error(
+          `Parameter ${path} defaults to .${expression.name}, which its enum does not declare.`
+        );
+      }
+      return optionId;
+    }
+    default:
+      throw new Error(
+        `Parameter ${path} default is not a constant expression.`
+      );
+  }
+}
+var init_lower_parameter_defaults = __esm({
+  "src/project-source/lower-parameter-defaults.ts"() {
+    "use strict";
+    init_src();
+    init_lower_support();
+  }
+});
+
 // src/project-source/init-source.ts
 function commentEndIndex(source, index) {
   if (source[index] !== "/") return null;
@@ -51700,12 +52567,21 @@ function lowerClassConstructors(context, declaration, classId, lowerParameterTyp
   const declared = declaration.constructors.map((declared2) => {
     const id2 = declaredConstructorId2(declaration, declared2);
     const base = context.baseConstructors.get(id2);
-    const parameters = declared2.parameters.map((parameter4) => ({
-      name: parameter4.name,
-      type: lowerParameterType(parameter4.type, declaration),
-      source: span({ source: parameter4.source }),
-      selectionSpan: span({ source: parameter4.source })
-    }));
+    const parameters = declared2.parameters.map((parameter4) => {
+      const parameterType = lowerParameterType(parameter4.type, declaration);
+      return {
+        name: parameter4.name,
+        type: parameterType,
+        default: lowerParameterDefault(
+          context,
+          parameter4,
+          parameterType,
+          `${declaration.name}.${declared2.name}(${parameter4.name})`
+        ),
+        source: span({ source: parameter4.source }),
+        selectionSpan: span({ source: parameter4.source })
+      };
+    });
     const baseArguments = (declared2.baseArguments ?? []).map((argument2) => ({
       name: argument2.name,
       code: argument2.expression.trim()
@@ -51746,12 +52622,21 @@ function lowerRequiredConstructor(context, declaration, classId, lowerParameterT
       selectionSpan: sourceSpan
     },
     classId,
-    arguments: required2.parameters.map((parameter4) => ({
-      name: parameter4.name,
-      type: lowerParameterType(parameter4.type, declaration),
-      source: span({ source: parameter4.source }),
-      selectionSpan: span({ source: parameter4.source })
-    })),
+    arguments: required2.parameters.map((parameter4) => {
+      const parameterType = lowerParameterType(parameter4.type, declaration);
+      return {
+        name: parameter4.name,
+        type: parameterType,
+        default: lowerParameterDefault(
+          context,
+          parameter4,
+          parameterType,
+          `${declaration.name}(${parameter4.name})`
+        ),
+        source: span({ source: parameter4.source }),
+        selectionSpan: span({ source: parameter4.source })
+      };
+    }),
     code: requiredConstructorBody(required2.body, base?.code),
     ...baseArguments.length === 0 ? {} : {
       baseArguments: baseArguments.map(
@@ -51834,10 +52719,10 @@ function recordBaseParameterNames(context, baseName, suppliedNames) {
 function selectOverload(candidates, suppliedNames) {
   if (candidates.length === 0) return null;
   if (candidates.length === 1) return candidates[0];
-  const key = argumentNameSetKey2(suppliedNames);
-  return candidates.find((names) => argumentNameSetKey2(names) === key) ?? null;
+  const key = argumentNameSetKey(suppliedNames);
+  return candidates.find((names) => argumentNameSetKey(names) === key) ?? null;
 }
-function argumentNameSetKey2(names) {
+function argumentNameSetKey(names) {
   return [...names].map((name) => name.toLowerCase()).sort().join(",");
 }
 function baseTypeName(declaration) {
@@ -51876,6 +52761,7 @@ var init_lower_constructors = __esm({
     init_src();
     init_required_constructor_id();
     init_declared_constructors2();
+    init_lower_parameter_defaults();
     init_init_source();
     init_lower_support();
   }
@@ -52223,12 +53109,21 @@ function lowerMemberKind(context, ownerClass, declaration, id2, owner) {
   if (declaration.kind === "function") {
     const returnType = declaration.type.name === "void" ? { kind: "void", nullable: false } : lowerType(context, declaration.type, ownerClass);
     const argumentsValue = declaration.parameters.map(
-      (parameter4) => ({
-        name: parameter4.name,
-        type: lowerType(context, parameter4.type, ownerClass),
-        source: span(parameter4),
-        selectionSpan: span(parameter4)
-      })
+      (parameter4) => {
+        const parameterType = lowerType(context, parameter4.type, ownerClass);
+        return {
+          name: parameter4.name,
+          type: parameterType,
+          default: lowerParameterDefault(
+            context,
+            parameter4,
+            parameterType,
+            `${ownerClass.name}.${declaration.name}(${parameter4.name})`
+          ),
+          source: span(parameter4),
+          selectionSpan: span(parameter4)
+        };
+      }
     );
     const settings = annotation(declaration.annotations, "settings");
     const logicMode = contextualEnumArgument(settings, "logic");
@@ -52458,6 +53353,7 @@ function lowerFieldMember(context, ownerClass, declaration, id2, commonInput, ba
       arguments: fieldType.arguments.slice(1).map((argumentType, index) => ({
         name: `p${index + 1}`,
         type: lowerType(context, argumentType, ownerClass),
+        default: null,
         source: span(declaration),
         selectionSpan: span(declaration)
       }))
@@ -52482,6 +53378,7 @@ function lowerFieldMember(context, ownerClass, declaration, id2, commonInput, ba
       arguments: fieldType.arguments.map((argumentType, index) => ({
         name: `p${index + 1}`,
         type: lowerType(context, argumentType, ownerClass),
+        default: null,
         source: span(declaration),
         selectionSpan: span(declaration)
       }))
@@ -52941,12 +53838,21 @@ function lowerInterface(context, declaration) {
         name: member.name,
         ...member.docsText === void 0 ? {} : { docsText: member.docsText },
         returnType: member.type.name === "void" ? { kind: "void", nullable: false } : lowerType(context, member.type),
-        arguments: member.parameters.map((parameter4) => ({
-          name: parameter4.name,
-          type: lowerType(context, parameter4.type),
-          source: span(parameter4),
-          selectionSpan: span(parameter4)
-        })),
+        arguments: member.parameters.map((parameter4) => {
+          const parameterType = lowerType(context, parameter4.type);
+          return {
+            name: parameter4.name,
+            type: parameterType,
+            default: lowerParameterDefault(
+              context,
+              parameter4,
+              parameterType,
+              `${declaration.name}.${member.name}(${parameter4.name})`
+            ),
+            source: span(parameter4),
+            selectionSpan: span(parameter4)
+          };
+        }),
         deferred: member.modifiers.includes("async"),
         accessModifier,
         source
@@ -53471,6 +54377,16 @@ function lowerExpressionValue(context, expression, declaredExpected, ownerClass,
       if (expression.callee.kind === "ident" && expression.callee.name === "Reference") {
         const index = expression.argumentNames?.findIndex((name) => name === "id") ?? -1;
         if (index >= 0) {
+          if (expression.argumentNames?.includes("withProvenance") === true) {
+            throw new Error(
+              `${path} writes Reference(id: ..., withProvenance: ...) as a persisted member value. Provenance-aware references are executable NeoScript values and must be used inside a function or delegate closure.`
+            );
+          }
+          if (expression.args.length !== 1 || expression.argumentNames?.some((name) => name !== "id")) {
+            throw new Error(
+              `${path} writes Reference(id: ...) with unsupported arguments.`
+            );
+          }
           const idArgument = expression.args[index];
           if (idArgument?.kind === "litString") return idArgument.value;
           throw new Error(
@@ -54264,6 +55180,7 @@ var init_lower_members = __esm({
     init_src();
     init_lower_support();
     init_lower_constructors();
+    init_lower_parameter_defaults();
     init_declared_constructors2();
     init_init_source();
     init_ui_action_source();
@@ -54399,7 +55316,8 @@ function createNeoScriptDocumentContext(context, projectOverride) {
   const parameters = context.functionArguments?.map((argument2, index) => ({
     id: `function-parameter:${index}:${argument2.name}`,
     name: argument2.name,
-    type: toLanguageType(argument2, context)
+    type: toLanguageType(argument2, context),
+    ...parameterDefaultDescriptor(argument2, context)
   }));
   return {
     kind: documentKind,
@@ -54421,6 +55339,32 @@ function createNeoScriptDocumentContext(context, projectOverride) {
     } : {}
   };
 }
+function parameterDefaultDescriptor(argument2, context) {
+  if (argument2.defaultValue === void 0) return {};
+  const value = argument2.defaultValue.value;
+  const enumOptionName = argument2.type === 8 /* Enum */ && typeof value === "string" ? analyzerEnumOptionName(argument2.enumId, value, context) : void 0;
+  return {
+    defaultValue: {
+      displayText: neoScriptParameterDefaultDisplayText({
+        value,
+        kind: parameterDefaultSpellingKind(argument2.type),
+        ...enumOptionName === void 0 ? {} : { enumOptionName }
+      }),
+      value
+    }
+  };
+}
+function parameterDefaultSpellingKind(type) {
+  if (type === 8 /* Enum */) return "enum";
+  if (type === 20 /* Decimal */) return "decimal";
+  return "other";
+}
+function analyzerEnumOptionName(enumId, optionId, context) {
+  const enumDefinition = context.vm.enums.find(
+    (candidate) => candidate.id === enumId
+  );
+  return enumDefinition?.options[optionId]?.name;
+}
 function createNeoScriptProject(context) {
   const languageTypes = [];
   for (const schemaClass2 of context.vm.classes) {
@@ -54708,7 +55652,8 @@ function declaredConstructors(schemaClass2, context) {
         parameters: record3.argumentTypes.map((argument2) => ({
           name: argument2.name,
           type: toLanguageType(argument2, context),
-          required: argument2.required
+          required: argument2.required,
+          ...parameterDefaultDescriptor(argument2, context)
         })),
         ...record3.docsText ? { documentation: record3.docsText } : {},
         ...record3.id === required2 ? { required: true } : {}
@@ -54784,7 +55729,8 @@ function memberToSymbol(record3, schemaKey, containingClass2, ownerClassId, inde
         (argument2, argumentIndex) => ({
           id: `${record3.id}:argument:${argumentIndex}`,
           name: argument2.name,
-          type: toLanguageType(argument2, context, genericEnvironment)
+          type: toLanguageType(argument2, context, genericEnvironment),
+          ...parameterDefaultDescriptor(argument2, context)
         })
       ),
       deferred: authoredCallable.deferred,
@@ -54955,7 +55901,8 @@ function interfaceMemberToSymbol(neoInterface, key, member, context, inherited)
       parameters: member.argumentTypes.map((argument2, index) => ({
         id: `${neoInterface.id}:member:${key}:argument:${index}`,
         name: argument2.name,
-        type: toLanguageType(argument2, context)
+        type: toLanguageType(argument2, context),
+        ...parameterDefaultDescriptor(argument2, context)
       })),
       deferred: member.deferred,
       abstract: true,
@@ -56535,13 +57482,13 @@ function resolveBaseConstructorOverload(args, owner) {
       `Constructor "${args.constructor.id}" declares a base call, but base class "${baseClass.name}" declares no constructors.`
     );
   }
-  const requested = argumentNameSetKey3(
+  const requested = argumentNameSetKey2(
     (args.constructor.baseArguments ?? []).map(
       (baseArgument) => baseArgument.name
     )
   );
   const matches = candidates.filter(
-    (candidate) => argumentNameSetKey3(
+    (candidate) => argumentNameSetKey2(
       candidate.argumentTypes.map((argument2) => argument2.name)
     ) === requested
   );
@@ -56597,7 +57544,7 @@ function declaredConstructorsOfClass(constructors, schemaClass2) {
     return [record3];
   });
 }
-function argumentNameSetKey3(names) {
+function argumentNameSetKey2(names) {
   return [...names].map((name) => name.toLowerCase()).sort().join(", ");
 }
 function describeConstructorOverloads(constructors) {
@@ -59019,13 +59966,14 @@ function evaluatorOwnershipDistances(rowId, indexes) {
   indexes.ownershipDistancesByRowId.set(rowId, distances);
   return distances;
 }
-function resolveRuntimeReferenceRow(sourceValueId, ctx) {
+function resolveRuntimeReferenceRow(sourceValueId, ctx, withProvenance) {
   const direct = evalValueById(
     ctx,
     sourceValueId,
     ctx.__runtimeSessionValues,
     ctx.__valueOverlay
   );
+  if (!withProvenance) return direct;
   const receiver = trackedRowForValueReference(ctx.thisValue, ctx);
   if (receiver === null) return direct;
   const indexes = evaluatorIndexes(ctx);
@@ -59911,16 +60859,21 @@ function executeCompiledFunction(action, ctx, args, allowFallthroughReturn, runt
       `Corrupt NSFunction IR: compiled body has ${action.parameters.length - 2} argument parameter(s), but its runtime signature declares ${expectedCount}.`
     );
   }
-  if (args.length !== expectedCount) {
+  const filledArgs = runtimeSignature === void 0 ? args : fillTrailingParameterDefaults(
+    args,
+    runtimeSignature.argumentTypes,
+    "NSFunction"
+  );
+  if (filledArgs.length !== expectedCount) {
     throw new NSGetterRuntimeError(
-      `NSFunction expected ${expectedCount} argument(s), got ${args.length}.`
+      `NSFunction expected ${expectedCount} argument(s), got ${filledArgs.length}.`
     );
   }
   const scope = createTopLevelScope(ctx);
-  for (let index = 0; index < args.length; index += 1) {
+  for (let index = 0; index < filledArgs.length; index += 1) {
     const parameter4 = action.parameters[index + 2];
     const runtimeTypeInfo = runtimeArgumentTypes[index];
-    const value2 = args[index];
+    const value2 = filledArgs[index];
     if (!runtimeValueMatchesType(value2, runtimeTypeInfo, ctx)) {
       throw new NSGetterRuntimeError(
         `NSFunction argument ${index + 1} does not match its declared runtime type.`
@@ -59961,6 +60914,57 @@ function executeCompiledFunction(action, ctx, args, allowFallthroughReturn, runt
   }
   return value;
 }
+function fillTrailingParameterDefaults(args, argumentTypes, subject) {
+  const maxArity = argumentTypes.length;
+  const minArity = argumentTypes.filter(
+    (parameter4) => !parameterHasDefault(parameter4)
+  ).length;
+  const expectedArity = minArity === maxArity ? `${maxArity} argument(s)` : `between ${minArity} and ${maxArity} argument(s)`;
+  if (args.length > maxArity) {
+    throw new NSGetterRuntimeError(
+      `${subject} expected ${expectedArity}, got ${args.length}.`
+    );
+  }
+  if (args.length < minArity) {
+    throw new NSGetterRuntimeError(
+      `${subject} expected ${expectedArity}, got ${args.length}.`
+    );
+  }
+  if (args.length === maxArity) return args;
+  const filled = [...args];
+  for (let index = args.length; index < maxArity; index += 1) {
+    const parameter4 = argumentTypes[index];
+    if (parameter4 === void 0) {
+      throw new NSGetterRuntimeError(
+        `${subject} has a hole in its argument types at position ${index}.`
+      );
+    }
+    filled.push(parameterDefaultRuntimeValue(parameter4, subject));
+  }
+  return filled;
+}
+function parameterDefaultRuntimeValue(parameter4, subject) {
+  const defaultValue = parameter4.defaultValue;
+  if (defaultValue === void 0) {
+    throw new NSGetterRuntimeError(
+      `${subject} parameter '${parameter4.name}' was omitted but declares no default.`
+    );
+  }
+  if (defaultValue.value === null) return null;
+  if (parameter4.type === 8 /* Enum */) return [defaultValue.value];
+  return defaultValue.value;
+}
+function fillCallableCallSiteArguments(args, member, ctx) {
+  if (member === null) return args;
+  if (member.kind !== 13 /* Function */ && member.kind !== 23 /* NSFunction */) {
+    return args;
+  }
+  const signature = resolveCallableSignature(member.id, member.kind, ctx);
+  if (signature === null) return args;
+  if (!hasAnyParameterDefault(signature.argumentTypes)) return args;
+  const subject = member.kind === 13 /* Function */ ? `Function '${member.name}'` : `NSFunction '${member.name}'`;
+  return fillTrailingParameterDefaults(args, signature.argumentTypes, subject);
+}
 function createChildScope(parent) {
   return new NeoScriptScope(parent);
 }
@@ -61180,7 +62184,11 @@ function evalPointer(pointer, scope, ctx) {
       return scope.get(pointer.variableId);
     }
     case "reference" /* reference */: {
-      const row = resolveRuntimeReferenceRow(pointer.valueId, ctx);
+      const row = resolveRuntimeReferenceRow(
+        pointer.valueId,
+        ctx,
+        pointer.withProvenance === true
+      );
       if (!row) {
         throw new NSGetterRuntimeError(
           `Missing value reference: ${pointer.valueId}`
@@ -61257,8 +62265,11 @@ function evalPointer(pointer, scope, ctx) {
       if (pointer.receiver.kind === "instance" && pointer.optional === true && (innerThis === null || innerThis === void 0)) {
         return null;
       }
-      const args = pointer.args.map((arg) => evalPointer(arg, scope, ctx));
+      const suppliedArgs = pointer.args.map(
+        (arg) => evalPointer(arg, scope, ctx)
+      );
       const member = pointer.receiver.kind === "static" ? evalMemberById(ctx.vm, pointer.receiver.memberId) : resolveEffectiveCallableMember(pointer, innerThis, ctx);
+      const args = fillCallableCallSiteArguments(suppliedArgs, member, ctx);
       const interceptedMemberId = member?.id ?? pointer.memberId ?? pointer.memberKey ?? pointer.callSiteId;
       consumeBudget(ctx, "workUnits", 1, "work unit");
       const intercepted = ctx.callInterceptor?.({
@@ -61781,13 +62792,21 @@ function substituteCallableSignatureForReceiver(signature, receiver, ctx) {
         ctx
       ),
       argumentTypes: signature.argumentTypes.map((argument2) => {
+        if (!typeInfoContainsGeneric(argument2)) return argument2;
         const substituted = substituteRuntimeTypeInfo(argument2, env, ctx);
         if (substituted.type === NS_TYPE_VOID) {
           throw new NSGetterRuntimeError(
             `Generic NSFunction argument '${argument2.name}' resolved to Void.`
           );
         }
-        return { ...substituted, name: argument2.name };
+        const named = { ...substituted, name: argument2.name };
+        if (argument2.defaultValue === void 0) return named;
+        if (argument2.defaultValue.value !== null) {
+          throw new NSGetterRuntimeError(
+            `Generic NSFunction parameter '${argument2.name}' carries a non-null constant default, which a generic parameter cannot declare.`
+          );
+        }
+        return { ...named, defaultValue: { value: null } };
       })
     };
   } catch (error) {
@@ -64262,15 +65281,21 @@ function resolveDeclaredConstructorRecord(info, schemaClass2, ctx) {
       `Declared constructor call on '${schemaClass2.name}' passes the same argument name twice.`
     );
   }
-  if (suppliedNames.length !== record3.argumentTypes.length) {
+  const supplied = new Set(suppliedNames);
+  for (const parameter4 of record3.argumentTypes) {
+    if (supplied.has(parameter4.name)) continue;
+    if (parameterHasDefault(parameter4)) continue;
     throw new NSGetterRuntimeError(
-      `Constructor '${record3.id}' on '${schemaClass2.name}' declares ${record3.argumentTypes.length} parameter(s) but the call site passes ${suppliedNames.length}.`
+      `Declared constructor call on '${schemaClass2.name}' has no argument for parameter '${parameter4.name}'.`
     );
   }
-  for (const parameter4 of record3.argumentTypes) {
-    if (suppliedNames.includes(parameter4.name)) continue;
+  const declaredNames = new Set(
+    record3.argumentTypes.map((parameter4) => parameter4.name)
+  );
+  for (const name of suppliedNames) {
+    if (declaredNames.has(name)) continue;
     throw new NSGetterRuntimeError(
-      `Declared constructor call on '${schemaClass2.name}' has no argument for parameter '${parameter4.name}'.`
+      `Declared constructor call on '${schemaClass2.name}' names unknown parameter '${name}'.`
     );
   }
   return record3;
@@ -64281,6 +65306,12 @@ function evaluateDeclaredConstructorArguments(info, record3, scope, ctx) {
     byName.set(argument2.name, evalPointer(argument2.valuePointer, scope, ctx));
   }
   return record3.argumentTypes.map((parameter4) => {
+    if (!byName.has(parameter4.name)) {
+      return parameterDefaultRuntimeValue(
+        parameter4,
+        `Constructor '${record3.id}'`
+      );
+    }
     const value = byName.get(parameter4.name);
     if (parameter4.type !== 20 /* Decimal */) return value;
     if (typeof value !== "number") return value;
@@ -64311,7 +65342,7 @@ function resolveBaseConstructorRecord(record3, ctx) {
   if (baseArguments.length === 0) {
     if (candidates.length === 0) return null;
     const parameterless = candidates.find(
-      (candidate) => candidate.argumentTypes.length === 0
+      (candidate) => candidate.argumentTypes.every(parameterHasDefault)
     );
     if (parameterless === void 0) {
       throw new NSGetterRuntimeError(
@@ -64322,17 +65353,32 @@ function resolveBaseConstructorRecord(record3, ctx) {
   }
   const names = new Set(baseArguments.map((argument2) => argument2.name));
   const matches = candidates.filter(
-    (candidate) => candidate.argumentTypes.length === names.size && candidate.argumentTypes.every((parameter4) => names.has(parameter4.name))
+    (candidate) => candidate.argumentTypes.every(
+      (parameter4) => names.has(parameter4.name) || parameterHasDefault(parameter4)
+    ) && [...names].every(
+      (name) => candidate.argumentTypes.some((parameter4) => parameter4.name === name)
+    )
   );
-  const firstMatch = matches[0];
-  if (firstMatch === void 0) {
+  if (matches.length === 0) {
     throw new NSGetterRuntimeError(
       `Constructor '${record3.id}' on '${owningClass.name}' calls ': base(${[...names].join(", ")})', which matches no constructor on its base class.`
     );
   }
-  if (matches.length > 1) {
+  const fewestFillIns = Math.min(
+    ...matches.map((candidate) => candidate.argumentTypes.length - names.size)
+  );
+  const best = matches.filter(
+    (candidate) => candidate.argumentTypes.length - names.size === fewestFillIns
+  );
+  const firstMatch = best[0];
+  if (firstMatch === void 0) {
+    throw new NSGetterRuntimeError(
+      `Constructor '${record3.id}' on '${owningClass.name}' resolved ': base(${[...names].join(", ")})' to an empty betterness set.`
+    );
+  }
+  if (best.length > 1) {
     throw new NSGetterRuntimeError(
-      `Constructor '${record3.id}' on '${owningClass.name}' calls ': base(${[...names].join(", ")})', which matches ${matches.length} base constructors: ${matches.map((candidate) => candidate.id).join(", ")}.`
+      `Constructor '${record3.id}' on '${owningClass.name}' calls ': base(${[...names].join(", ")})', which matches ${best.length} base constructors: ${best.map((candidate) => candidate.id).join(", ")}.`
     );
   }
   return firstMatch;
@@ -64366,6 +65412,12 @@ function evaluateBaseConstructorArguments(record3, baseRecord, argumentValues, t
   }
   return baseRecord.argumentTypes.map((parameter4) => {
     if (!byName.has(parameter4.name)) {
+      if (parameterHasDefault(parameter4)) {
+        return parameterDefaultRuntimeValue(
+          parameter4,
+          `Constructor '${baseRecord.id}'`
+        );
+      }
       throw new NSGetterRuntimeError(
         `Constructor '${record3.id}' calls ': base(...)' without an argument for base parameter '${parameter4.name}'.`
       );
@@ -66479,12 +67531,15 @@ function isNeoClassConstructorBase(value) {
   if (typeof v.code !== "string" && v.code !== null) return false;
   if (!Array.isArray(v.argumentTypes)) return false;
   const parameterNames = /* @__PURE__ */ new Set();
+  const argumentTypes = [];
   for (const argument2 of v.argumentTypes) {
     if (!isNSFunctionArgumentTypeInfo(argument2)) return false;
     if (!isValidCallableIdentifier(argument2.name)) return false;
     if (parameterNames.has(argument2.name)) return false;
     parameterNames.add(argument2.name);
+    argumentTypes.push(argument2);
   }
+  if (validateParameterDefaults(argumentTypes).length > 0) return false;
   if (v.baseArguments !== void 0 && v.baseArguments !== null) {
     if (!Array.isArray(v.baseArguments)) return false;
     const baseNames = /* @__PURE__ */ new Set();
@@ -76040,7 +77095,7 @@ function stableValue(value) {
   if (Array.isArray(value)) return value.map(stableValue);
   if (!isRecord7(value)) return value;
   const normalized = Object.fromEntries(
-    Object.entries(value).filter(([key]) => key !== "name").sort(([left], [right]) => left.localeCompare(right)).map(([key, entry]) => [key, stableValue(entry)])
+    Object.entries(value).filter(([key]) => key !== "name" && key !== "defaultValue").sort(([left], [right]) => left.localeCompare(right)).map(([key, entry]) => [key, stableValue(entry)])
   );
   return normalized;
 }
@@ -76142,11 +77197,81 @@ function isOpaqueNSFunctionReturnTypeInfo(value) {
   return isOpaqueNSTypeInfo(value);
 }
 function isOpaqueNSFunctionArgumentTypeInfo(value) {
-  return isOpaqueNSTypeInfo(value) && isOpaqueCallableIdentifier(value.name) && !opaqueTypeInfoContainsUnknown(value);
+  return isOpaqueNSTypeInfo(value) && isOpaqueCallableIdentifier(value.name) && !opaqueTypeInfoContainsUnknown(value) && hasValidOpaqueParameterDefault(value);
 }
 function isOpaqueConstructorArgumentTypeInfo(value) {
   if (!isRecord7(value)) return false;
-  return isOpaqueNSTypeInfo(value) && (value.name === "value" || isOpaqueCallableIdentifier(value.name)) && !opaqueTypeInfoContainsUnknown(value);
+  return isOpaqueNSTypeInfo(value) && (value.name === "value" || isOpaqueCallableIdentifier(value.name)) && !opaqueTypeInfoContainsUnknown(value) && hasValidOpaqueParameterDefault(value);
+}
+function hasValidOpaqueParameterDefault(value) {
+  const wrapper = value.defaultValue;
+  if (wrapper === void 0) return true;
+  if (!isRecord7(wrapper)) return false;
+  const keys = Object.keys(wrapper);
+  if (keys.length !== 1 || keys[0] !== "value") return false;
+  const payload = wrapper.value;
+  if (payload === null) return value.required === false;
+  if (value.type === 1) return typeof payload === "boolean";
+  if (value.type === 2) {
+    return typeof payload === "number" && Number.isInteger(payload);
+  }
+  if (value.type === 4) {
+    return typeof payload === "number" && Number.isFinite(payload);
+  }
+  if (value.type === 3 || value.type === 8 || value.type === 20) {
+    return typeof payload === "string";
+  }
+  return false;
+}
+function opaqueParameterDefaultsPlacedLast(argumentTypes) {
+  let seenDefault = false;
+  for (const argument2 of argumentTypes) {
+    if (argument2.defaultValue !== void 0) {
+      seenDefault = true;
+      continue;
+    }
+    if (seenDefault) return false;
+  }
+  return true;
+}
+function opaqueArgumentsHaveDefault(argumentTypes) {
+  return argumentTypes.some(
+    (argument2) => isRecord7(argument2) && argument2.defaultValue !== void 0
+  );
+}
+function assertOpaqueParameterDefaultsValid(member) {
+  const argumentTypes = member.argumentTypes;
+  if (!Array.isArray(argumentTypes)) return;
+  if (!opaqueArgumentsHaveDefault(argumentTypes)) return;
+  if (member.kind === 25 || member.kind === 26) {
+    throw new Error(
+      `Member "${member.name}" (${member.id}) is a delegate or action, whose parameters are an unnamed positional type list and cannot carry a default value.`
+    );
+  }
+  if (member.kind !== 13 && member.kind !== 23) {
+    throw new Error(
+      `Member "${member.name}" (${member.id}) is not callable and cannot declare parameter default values.`
+    );
+  }
+  if (member.deferred === true) {
+    throw new Error(
+      `Function "${member.name}" (${member.id}) is deferred, and generated C# appends a trailing deferred parameter that a defaulted parameter cannot precede.`
+    );
+  }
+  const parameters = [];
+  for (const argument2 of argumentTypes) {
+    if (!isRecord7(argument2) || !hasValidOpaqueParameterDefault(argument2)) {
+      throw new Error(
+        `Function "${member.name}" (${member.id}) declares a parameter default value that does not match the parameter's type.`
+      );
+    }
+    parameters.push(argument2);
+  }
+  if (!opaqueParameterDefaultsPlacedLast(parameters)) {
+    throw new Error(
+      `Function "${member.name}" (${member.id}) declares a defaulted parameter before a non-defaulted one; defaulted parameters must come last.`
+    );
+  }
 }
 function memberSignature(member) {
   if (member.kind === "property") {
@@ -76180,6 +77305,7 @@ function assertProjectInterfaceDocumentValid(view, options = {}) {
   }
   for (const member of members) {
     assertOpaqueMemberDefaultValueValid(member);
+    assertOpaqueParameterDefaultsValid(member);
     assertOpaqueCallableOverrideValid(member, membersById);
     assertOpaqueNSFunctionValid(member, membersById);
     if (member.isAbstract === true && member.defaultValue != null) {
@@ -77556,11 +78682,11 @@ function assertOpaqueConstructorValid(declaredConstructor) {
       );
     }
     names.add(name);
-    if (argument2.defaultValue !== void 0) {
-      throw new Error(
-        `Constructor "${declaredConstructor.id}" parameter "${name}" declares a default value, which constructors do not support; add an overload instead.`
-      );
-    }
+  }
+  if (!opaqueParameterDefaultsPlacedLast(argumentTypes)) {
+    throw new Error(
+      `Constructor "${declaredConstructor.id}" declares a defaulted parameter before a non-defaulted one; defaulted parameters must come last.`
+    );
   }
   assertOpaqueCompiledConstructorAction(declaredConstructor, argumentTypes);
   assertOpaqueConstructorBaseClauseValid(declaredConstructor);
@@ -103403,8 +104529,8 @@ var init_registry2 = __esm({
     "use strict";
     PROJECT_SCHEMA_CONTRACT = Object.freeze({
       formatVersion: 3,
-      contractVersion: "3.9",
-      cliVersion: "0.27.1",
+      contractVersion: "3.10",
+      cliVersion: "0.29.0",
       projectFileUploadBatchSize: 32,
       documentRecords: {
         member: {
@@ -109970,7 +111096,7 @@ There is no --keep-current: preserving current semantic state defines flatten.
 async function main() {
   const args = parseArgs(process.argv.slice(2));
   if (args.command === "--version") {
-    console.log("0.27.1");
+    console.log("0.29.0");
     return;
   }
   if (args.command === null || args.command === "help" || args.command === "--help" || args.command === "-h") {