@neocompose/cli 0.27.0 → 0.28.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();
   }
 });
 
@@ -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(
@@ -12673,9 +12818,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(
+            functionArityMessage(
+              symbol.name,
+              minimumArguments,
+              parameters.length,
+              argumentsList2.length
+            ),
+            pos
+          );
+        }
+        if (argumentsList2.length > parameters.length) {
           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
           );
         }
@@ -12890,13 +13054,13 @@ var init_strict_resolver = __esm({
             scope,
             pos
           );
-          const selected2 = intrinsic(
+          const selected = intrinsic(
             "select" /* Select */,
             { collectionPointer: receiver.pointer, function: fn },
             { kind: "list", elementType: resultType, readOnly: true }
           );
           return {
-            ...selected2,
+            ...selected,
             entryWritability: inferredReturn.writability,
             writeRoot: inferredReturn.writeRoot
           };
@@ -16595,12 +16759,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 +17350,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 +19449,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 +19736,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 +19752,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 +19764,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 +19809,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 +19818,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 +19952,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 +19986,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();
@@ -24443,6 +24649,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 +24923,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 +25532,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 +25852,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}: `
       }))
     };
@@ -25851,9 +26278,9 @@ function declaredConstructorNamedArguments(analysis, typeName, used) {
       )
     )
   );
-  const selected2 = reachable.length > 0 ? reachable : contract.constructors;
+  const selected = reachable.length > 0 ? reachable : contract.constructors;
   const fields = /* @__PURE__ */ new Map();
-  for (const constructor2 of selected2) {
+  for (const constructor2 of selected) {
     for (const parameter4 of constructor2.parameters) {
       if (fields.has(parameter4.name)) continue;
       fields.set(parameter4.name, parameterArgumentField(parameter4));
@@ -25862,7 +26289,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 +26353,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 +26486,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 +26501,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}.`);
   }
@@ -26187,13 +26623,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 +27393,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 +27422,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 +27545,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 +27653,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 +27851,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 +28072,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 +28483,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 +28930,7 @@ function projectSchemaManifest(input, options = {}) {
     members: memberById,
     classes: schemaClassById,
     interfaces: interfaceById,
+    enums: indexById(enums, "ProjectSchemaManifest.enums"),
     genericNames,
     effectiveWritabilityByMemberId: effectiveMemberWritability(
       members,
@@ -28469,7 +28992,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 +30003,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 +30016,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 {};
@@ -29499,14 +30076,14 @@ function sourceLocation(value, environment, field) {
 }
 function spanAndSelectionLocations(spanValue, selectionValue, environment, field) {
   const navigation = spanLocation(spanValue, environment, field);
-  const selection = spanLocation(
+  const selection2 = spanLocation(
     selectionValue,
     environment,
     `${field}.selection`
   );
   return {
     ...navigation,
-    ...selection.location ? { selectionLocation: selection.location } : {}
+    ...selection2.location ? { selectionLocation: selection2.location } : {}
   };
 }
 function scriptDefinitionLocations(member, environment, field) {
@@ -30436,6 +31013,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();
@@ -31222,6 +31800,9 @@ function normalizeDocumentFields(recordKind, value) {
     if (current === void 0) normalized[field] = null;
   }
   if (recordKind === "member") {
+    if (CALLABLE_MEMBER_KINDS.has(normalized.kind)) {
+      normalized.required = false;
+    }
     normalizeTypeInfoBindings(normalized.returnTypeInfo);
     if (Array.isArray(normalized.argumentTypes)) {
       for (const argument2 of normalized.argumentTypes) {
@@ -31333,13 +31914,14 @@ function deepNormalizeValue(value) {
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-var SchemaDocumentContractError;
+var CALLABLE_MEMBER_KINDS, SchemaDocumentContractError;
 var init_contracts = __esm({
   "src/project-manifest/contracts.ts"() {
     "use strict";
     init_document_contracts();
     init_machine_strings();
     init_document_contracts();
+    CALLABLE_MEMBER_KINDS = /* @__PURE__ */ new Set([13, 23]);
     SchemaDocumentContractError = class extends Error {
       constructor(recordKind, field) {
         super(
@@ -31365,6 +31947,8 @@ function threeWayMergeRecord(base, server, local, policy = {}) {
   const comparisonServer = policy.comparison?.server ?? serverRecord;
   const comparisonLocal = policy.comparison?.local ?? localRecord;
   const merged = {};
+  const localVariant = {};
+  const serverVariant = {};
   const conflictFields = [];
   const keys = /* @__PURE__ */ new Set([
     ...Object.keys(serverRecord),
@@ -31375,7 +31959,11 @@ function threeWayMergeRecord(base, server, local, policy = {}) {
     const rawServerValue = serverRecord[key];
     const rawLocalValue = localRecord[key];
     if (policy.serverWinsFields?.has(key) === true) {
-      if (rawServerValue !== void 0) merged[key] = rawServerValue;
+      if (rawServerValue !== void 0) {
+        merged[key] = rawServerValue;
+        localVariant[key] = rawServerValue;
+        serverVariant[key] = rawServerValue;
+      }
       continue;
     }
     const baseValue = comparisonBase[key];
@@ -31396,25 +31984,31 @@ function threeWayMergeRecord(base, server, local, policy = {}) {
     } else if (result.present) {
       merged[key] = result.value;
     }
+    if (result.local.present) localVariant[key] = result.local.value;
+    if (result.server.present) serverVariant[key] = result.server.value;
   }
-  return { merged, conflictFields };
+  return { merged, localVariant, serverVariant, conflictFields };
 }
 function mergeValue(args) {
   if (canonicallyEqual(args.server, args.base)) {
-    return selected(args.rawLocal);
+    return sharedSelection(args.rawLocal);
   }
   if (canonicallyEqual(args.local, args.base)) {
-    return selected(args.rawServer);
+    return sharedSelection(args.rawServer);
   }
   if (canonicallyEqual(args.local, args.server)) {
-    return selected(args.rawLocal);
+    return sharedSelection(args.rawLocal);
+  }
+  if (!args.recursive) {
+    return conflict(args.path, args.rawLocal, args.rawServer);
   }
-  if (!args.recursive) return conflict(args.path);
   if (isObjectRecord2(args.rawBase) && isObjectRecord2(args.rawServer) && isObjectRecord2(args.rawLocal)) {
     const comparisonBase = isObjectRecord2(args.base) ? args.base : args.rawBase;
     const comparisonServer = isObjectRecord2(args.server) ? args.server : args.rawServer;
     const comparisonLocal = isObjectRecord2(args.local) ? args.local : args.rawLocal;
     const value = {};
+    const localVariant = {};
+    const serverVariant = {};
     const conflicts = [];
     const keys = /* @__PURE__ */ new Set([
       ...Object.keys(args.rawBase),
@@ -31434,8 +32028,16 @@ function mergeValue(args) {
       });
       conflicts.push(...nested.conflicts);
       if (nested.present) value[key] = nested.value;
+      if (nested.local.present) localVariant[key] = nested.local.value;
+      if (nested.server.present) serverVariant[key] = nested.server.value;
     }
-    return { present: true, value, conflicts };
+    return {
+      present: true,
+      value,
+      local: { present: true, value: localVariant },
+      server: { present: true, value: serverVariant },
+      conflicts
+    };
   }
   if (Array.isArray(args.rawBase) && Array.isArray(args.rawServer) && Array.isArray(args.rawLocal)) {
     return mergeIdentityArray(
@@ -31445,17 +32047,24 @@ function mergeValue(args) {
       args.path
     );
   }
-  return conflict(args.path);
+  return conflict(args.path, args.rawLocal, args.rawServer);
 }
 function mergeIdentityArray(base, server, local, path) {
   const baseItems = indexIdentityArray(base);
   const serverItems = indexIdentityArray(server);
   const localItems = indexIdentityArray(local);
   if (baseItems === null || serverItems === null || localItems === null) {
-    return conflict(path);
+    return conflict(path, local, server);
   }
-  const retained = /* @__PURE__ */ new Map();
+  const mergedValues = /* @__PURE__ */ new Map();
+  const localValues = /* @__PURE__ */ new Map();
+  const serverValues = /* @__PURE__ */ new Map();
   const conflicts = [];
+  const retainShared = (id2, value2) => {
+    mergedValues.set(id2, value2);
+    localValues.set(id2, value2);
+    serverValues.set(id2, value2);
+  };
   const ids = /* @__PURE__ */ new Set([
     ...baseItems.order,
     ...serverItems.order,
@@ -31471,46 +32080,79 @@ function mergeIdentityArray(base, server, local, path) {
     if (baseHas && !serverHas && !localHas) continue;
     if (baseHas && !serverHas) {
       if (canonicallyEqual(localValue, baseValue)) continue;
-      conflicts.push(`${path}[${JSON.stringify(id2)}]`);
+      conflicts.push(path + "[" + JSON.stringify(id2) + "]");
+      localValues.set(id2, localValue);
       continue;
     }
     if (baseHas && !localHas) {
       if (canonicallyEqual(serverValue, baseValue)) continue;
-      conflicts.push(`${path}[${JSON.stringify(id2)}]`);
+      conflicts.push(path + "[" + JSON.stringify(id2) + "]");
+      serverValues.set(id2, serverValue);
       continue;
     }
     if (!serverHas && localHas) {
-      retained.set(id2, localValue);
+      retainShared(id2, localValue);
       continue;
     }
     if (!localHas && serverHas) {
-      retained.set(id2, serverValue);
+      retainShared(id2, serverValue);
       continue;
     }
-    const merged = mergeValue({
+    const item = mergeValue({
       rawBase: baseValue,
       rawServer: serverValue,
       rawLocal: localValue,
       base: baseValue,
       server: serverValue,
       local: localValue,
-      path: `${path}[${JSON.stringify(id2)}]`,
+      path: path + "[" + JSON.stringify(id2) + "]",
       recursive: true
     });
-    conflicts.push(...merged.conflicts);
-    if (merged.present) retained.set(id2, merged.value);
+    conflicts.push(...item.conflicts);
+    if (item.present) mergedValues.set(id2, item.value);
+    if (item.local.present) localValues.set(id2, item.local.value);
+    if (item.server.present) serverValues.set(id2, item.server.value);
   }
-  if (conflicts.length > 0) return { present: true, value: [], conflicts };
-  const order = mergeIdentityOrder(
+  const retainedIds = /* @__PURE__ */ new Set([...localValues.keys(), ...serverValues.keys()]);
+  const sharedOrder = mergeIdentityOrder(
+    baseItems.order,
+    serverItems.order,
+    localItems.order,
+    retainedIds
+  );
+  if (sharedOrder === null) conflicts.push(path + ".$order");
+  const localOrder = sharedOrder?.filter((id2) => localValues.has(id2)) ?? completeVariantOrder(
+    localItems.order,
+    serverItems.order,
     baseItems.order,
+    new Set(localValues.keys())
+  );
+  const serverOrder = sharedOrder?.filter((id2) => serverValues.has(id2)) ?? completeVariantOrder(
     serverItems.order,
     localItems.order,
-    new Set(retained.keys())
+    baseItems.order,
+    new Set(serverValues.keys())
   );
-  if (order === null) return conflict(`${path}.$order`);
+  const localVariant = localOrder.map((id2) => localValues.get(id2));
+  const serverVariant = serverOrder.map((id2) => serverValues.get(id2));
+  if (conflicts.length > 0) {
+    return {
+      present: true,
+      value: [],
+      local: { present: true, value: localVariant },
+      server: { present: true, value: serverVariant },
+      conflicts
+    };
+  }
+  if (sharedOrder === null) {
+    throw new Error("A conflict-free identity merge must have a shared order.");
+  }
+  const value = sharedOrder.map((id2) => mergedValues.get(id2));
   return {
     present: true,
-    value: order.map((id2) => retained.get(id2)),
+    value,
+    local: { present: true, value },
+    server: { present: true, value },
     conflicts: []
   };
 }
@@ -31567,11 +32209,51 @@ function mergeIdentityOrder(base, server, local, retained) {
   }
   return result.length === nodes.length ? result : null;
 }
-function selected(value) {
-  return value === void 0 ? { present: false, conflicts: [] } : { present: true, value, conflicts: [] };
+function completeVariantOrder(preferred, fallback, base, retained) {
+  const result = preferred.filter((id2) => retained.has(id2));
+  const included = new Set(result);
+  for (const source of [fallback, base]) {
+    for (let index = 0; index < source.length; index += 1) {
+      const id2 = source[index];
+      if (!retained.has(id2) || included.has(id2)) continue;
+      let insertionIndex = -1;
+      for (let next = index + 1; next < source.length; next += 1) {
+        const nextIndex = result.indexOf(source[next]);
+        if (nextIndex !== -1) {
+          insertionIndex = nextIndex;
+          break;
+        }
+      }
+      if (insertionIndex === -1) {
+        for (let previous = index - 1; previous >= 0; previous -= 1) {
+          const previousIndex = result.indexOf(source[previous]);
+          if (previousIndex !== -1) {
+            insertionIndex = previousIndex + 1;
+            break;
+          }
+        }
+      }
+      if (insertionIndex === -1) insertionIndex = result.length;
+      result.splice(insertionIndex, 0, id2);
+      included.add(id2);
+    }
+  }
+  return result;
 }
-function conflict(path) {
-  return { present: false, conflicts: [path] };
+function selection(value) {
+  return value === void 0 ? { present: false } : { present: true, value };
+}
+function sharedSelection(value) {
+  const selected = selection(value);
+  return { ...selected, local: selected, server: selected, conflicts: [] };
+}
+function conflict(path, localValue, serverValue) {
+  return {
+    present: false,
+    local: selection(localValue),
+    server: selection(serverValue),
+    conflicts: [path]
+  };
 }
 var init_merge = __esm({
   "src/project-sync/merge.ts"() {
@@ -32297,10 +32979,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;
@@ -32312,16 +32991,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;
@@ -32411,11 +33084,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);
@@ -32564,6 +33251,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);
@@ -33303,10 +33997,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
       };
@@ -33805,10 +34496,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,
@@ -35464,14 +36152,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;
@@ -37685,7 +38381,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;
@@ -38486,6 +39205,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(
@@ -38622,6 +39386,7 @@ var init_neoscript = __esm({
     "use strict";
     init_neoscript_types();
     init_neoscript_guards();
+    init_parameter_defaults();
     init_type_info_compatibility();
   }
 });
@@ -39280,14 +40045,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) {
@@ -39335,6 +40106,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;
@@ -39342,7 +40114,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;
@@ -39419,6 +40193,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;
@@ -39457,6 +40232,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;
@@ -39688,6 +40464,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;
@@ -43566,7 +44343,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;
@@ -43634,6 +44415,7 @@ var init_interface_types = __esm({
     init_neoscript_types();
     init_docs_text2();
     init_neoscript_guards();
+    init_parameter_defaults();
     init_member_kinds();
   }
 });
@@ -45952,11 +46734,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 {
@@ -45971,7 +46788,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 ?? "";
@@ -46041,9 +46858,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")}
@@ -46091,9 +46906,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";
@@ -51176,13 +51989,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);
@@ -51194,6 +52007,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;
@@ -51203,16 +52020,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") {
@@ -51242,7 +52067,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;
@@ -51334,7 +52163,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) => ({
@@ -51360,6 +52190,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;
@@ -51596,12 +52522,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()
@@ -51642,12 +52577,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(
@@ -51702,13 +52646,13 @@ function sourceBaseParameterNames(context, baseName, suppliedNames) {
     return required2.parameters.map((parameter4) => parameter4.name);
   }
   const declared = context.declaredConstructors.byClassName.get(baseName) ?? [];
-  const selected2 = selectOverload(
+  const selected = selectOverload(
     declared.map(
       (constructor2) => constructor2.parameters.map((parameter4) => parameter4.name)
     ),
     suppliedNames
   );
-  return selected2;
+  return selected;
 }
 function recordBaseParameterNames(context, baseName, suppliedNames) {
   const baseClassId = context.classIdsByName.get(baseName);
@@ -51730,10 +52674,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) {
@@ -51772,6 +52716,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();
   }
@@ -52119,12 +53064,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");
@@ -52354,6 +53308,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)
       }))
@@ -52378,6 +53333,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)
       }))
@@ -52837,12 +53793,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
@@ -54160,6 +55125,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();
@@ -54295,7 +55261,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,
@@ -54317,6 +55284,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) {
@@ -54604,7 +55597,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 } : {}
@@ -54680,7 +55674,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,
@@ -54851,7 +55846,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,
@@ -56431,13 +57427,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
   );
@@ -56493,7 +57489,7 @@ function declaredConstructorsOfClass(constructors, schemaClass2) {
     return [record3];
   });
 }
-function argumentNameSetKey3(names) {
+function argumentNameSetKey2(names) {
   return [...names].map((name) => name.toLowerCase()).sort().join(", ");
 }
 function describeConstructorOverloads(constructors) {
@@ -59807,16 +60803,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.`
@@ -59857,6 +60858,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);
 }
@@ -61153,8 +62205,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?.({
@@ -61677,13 +62732,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) {
@@ -64158,15 +65221,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;
@@ -64177,6 +65246,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;
@@ -64207,7 +65282,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(
@@ -64218,17 +65293,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;
@@ -64262,6 +65352,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}'.`
       );
@@ -64639,7 +65735,7 @@ function evaluateInitializerInContext(init, member, ctx, createdValues, argument
   };
 }
 function encodeLookupInitializerResult(member, value, created, ctx) {
-  const selection = encodeLookupInitializerSelection(
+  const selection2 = encodeLookupInitializerSelection(
     member,
     value,
     created,
@@ -64651,7 +65747,7 @@ function encodeLookupInitializerResult(member, value, created, ctx) {
       ctx.__executionState?.constructorGroups.delete(row.id);
     }
   }
-  return { value: selection, classId: null };
+  return { value: selection2, classId: null };
 }
 function encodeLookupInitializerSelection(member, value, created, ctx) {
   if (value === null) return null;
@@ -66375,12 +67471,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();
@@ -72583,7 +73682,7 @@ var init_animation_clips = __esm({
         const seenChildren = /* @__PURE__ */ new Set();
         for (const row of rows) {
           const rowClassId = this.requireNodeClassId(row, "animationChildOverride");
-          const selected2 = this.resolveSelector(
+          const selected = this.resolveSelector(
             row,
             rowClassId,
             WORLD_ANIMATION_CHILD_OVERRIDE_SELECTOR_MEMBER_ID,
@@ -72591,8 +73690,8 @@ var init_animation_clips = __esm({
             args.selectorOwnerNode,
             `Animation clip "${args.clipName}" frame ${args.frameIndex} child override`
           );
-          if (selected2 === null) continue;
-          const { childId, childClassId, childNode: child } = selected2;
+          if (selected === null) continue;
+          const { childId, childClassId, childNode: child } = selected;
           if (!args.childIds.has(childId)) {
             throw new Error(
               `Animation clip "${args.clipName}" frame ${args.frameIndex} references child "${childId}" outside the owner's authored Children graph.`
@@ -72758,7 +73857,7 @@ var init_animation_clips = __esm({
        * segment's length is instance data this document does not have.
        */
       validateTrackBase(args) {
-        const selected2 = this.resolveSelector(
+        const selected = this.resolveSelector(
           args.track,
           args.trackClassId,
           WORLD_ANIMATION_TRACK_SELECTOR_MEMBER_ID,
@@ -72766,9 +73865,9 @@ var init_animation_clips = __esm({
           args.selectorOwnerNode,
           args.label
         );
-        if (selected2 !== null && !args.childIds.has(selected2.childId)) {
+        if (selected !== null && !args.childIds.has(selected.childId)) {
           throw new Error(
-            `${args.label} references child "${selected2.childId}" outside the owner's authored Children graph.`
+            `${args.label} references child "${selected.childId}" outside the owner's authored Children graph.`
           );
         }
         const startFrame = this.requireIntegerField(
@@ -72787,7 +73886,7 @@ var init_animation_clips = __esm({
         }
         this.validateTrackDirection(args.track, args.trackClassId, args.label);
         this.validateTrackCropWindow(args.track, args.trackClassId, args.label);
-        return selected2;
+        return selected;
       }
       resolveSelector(parent, classId, selectorMemberId, refreshMemberId, _selectorOwnerNode, label) {
         this.validateSelectorRefresh(parent, classId, refreshMemberId, label);
@@ -74258,7 +75357,7 @@ function explicitTargetIds(changes) {
   return result;
 }
 function selectedRecordIds(records2, explicitIds, impactedIds, impactedTypeNames, constructedClassIds, impactedSourceNames, ownerId = () => null) {
-  const selected2 = new Set(explicitIds);
+  const selected = new Set(explicitIds);
   for (const record3 of records2) {
     const owner = ownerId(record3);
     if (owner !== null && impactedIds.has(owner) || recordDependsOnChangedContract(
@@ -74268,10 +75367,10 @@ function selectedRecordIds(records2, explicitIds, impactedIds, impactedTypeNames
       constructedClassIds,
       impactedSourceNames
     )) {
-      selected2.add(record3.id);
+      selected.add(record3.id);
     }
   }
-  return selected2;
+  return selected;
 }
 function recordDependsOnChangedContract(record3, impactedIds, impactedTypeNames, constructedClassIds, impactedSourceNames) {
   const recordId = isObjectRecord3(record3) ? record3.id : void 0;
@@ -75936,7 +77035,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;
 }
@@ -76038,11 +77137,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") {
@@ -76076,6 +77245,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) {
@@ -77452,11 +78622,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);
@@ -85325,11 +86495,11 @@ var init_project_version_whole_graph_validation = __esm({
 
 // src/project-source/workspace-status-core.ts
 function listVirtualProjectSourceFilesV4(files) {
-  const selected2 = files.filter((file) => {
+  const selected = files.filter((file) => {
     const kind = neoProjectSourceKind(file.path);
     return kind !== null && isNeoProjectProductionSourceKind(kind) && !neoProjectPathHasIgnoredDirectory(file.path);
   });
-  const sorted = [...selected2].sort(
+  const sorted = [...selected].sort(
     (left, right) => compareWorkspacePaths(left.path, right.path)
   );
   for (let index = 1; index < sorted.length; index += 1) {
@@ -91393,9 +92563,6 @@ function resolveLookupCollectionValueIds(context, member, collection, ownerValue
     member.collectionMemberId,
     collection.name
   );
-  if (declaredRows.size > 0) {
-    return { valueIds: [...declaredRows], origin: "collectionMember" };
-  }
   const candidates = /* @__PURE__ */ new Set();
   const collectionState = context.state[`member:${member.collectionMemberId}`];
   const collectionMemberData = isObjectRecord2(collectionState?.data) ? collectionState.data : {};
@@ -91407,6 +92574,12 @@ function resolveLookupCollectionValueIds(context, member, collection, ownerValue
   ) ?? []) {
     candidates.add(placedValueId);
   }
+  if (declaredRows.size > 0) {
+    return {
+      valueIds: [.../* @__PURE__ */ new Set([...declaredRows, ...candidates])],
+      origin: "collectionMember"
+    };
+  }
   return { valueIds: [...candidates], origin: "nameScan" };
 }
 function collectionRowsOfDeclaredMember(context, collectionMemberId, schemaKey) {
@@ -92369,13 +93542,13 @@ function storedValueConstructor(context, schemaClass2, constructorArgs) {
       `Stored construction for ${schemaClass2.name} cannot select one constructor from ${candidates.length} ${count}-argument candidates.`
     );
   }
-  const selected2 = candidates[0];
-  if (selected2 === void 0) {
+  const selected = candidates[0];
+  if (selected === void 0) {
     throw new Error(
       `Stored construction for ${schemaClass2.name} resolved no constructor.`
     );
   }
-  return selected2;
+  return selected;
 }
 function storedConstructorArgumentSource(context, type, value, environment, visited, cloneAggregateArguments = false) {
   if (value === null) {
@@ -96073,7 +97246,7 @@ ${blockingErrors.map((error) => `  ${error.message}`).join("\n")}`
       continue;
     }
     const localSide = locallyDeleted ? {} : local;
-    const { merged, conflictFields } = mergeProjectDocumentRecord(
+    const { merged, localVariant, serverVariant, conflictFields } = mergeProjectDocumentRecord(
       serverRecord.recordKind,
       baseState.data,
       serverRecord.data,
@@ -96086,11 +97259,11 @@ ${blockingErrors.map((error) => `  ${error.message}`).join("\n")}`
       plans.set(key, {
         // The working copy renders the LOCAL side; the marker's other half
         // comes from the server-variant emission.
-        emitData: locallyDeleted ? void 0 : localSide,
+        emitData: locallyDeleted ? void 0 : localVariant,
         serverHash: serverRecord.contentHash,
         serverData: serverRecord.data,
         conflicted: true,
-        localData: locallyDeleted ? void 0 : localSide
+        serverEmitData: locallyDeleted ? serverRecord.data : serverVariant
       });
     } else {
       mergedCount += 1;
@@ -96125,8 +97298,7 @@ ${blockingErrors.map((error) => `  ${error.message}`).join("\n")}`
         emitData: local,
         serverHash: baseState.contentHash,
         serverData: void 0,
-        conflicted: true,
-        localData: local
+        conflicted: true
       });
       continue;
     }
@@ -96621,7 +97793,7 @@ function sourceComparableObjectRecord(recordKind, value, mainLocale) {
 function buildEmitRecordSet(document, plans, side) {
   const records2 = /* @__PURE__ */ new Map();
   for (const [key, plan] of plans) {
-    const data = side === "emit" ? plan.emitData : plan.serverData;
+    const data = side === "emit" ? plan.emitData : plan.serverEmitData ?? plan.serverData;
     if (data === void 0) continue;
     const serverRecord = document.records.get(key);
     const [recordKind, recordId] = key.split(/:(.+)/, 2);
@@ -103297,8 +104469,8 @@ var init_registry2 = __esm({
     "use strict";
     PROJECT_SCHEMA_CONTRACT = Object.freeze({
       formatVersion: 3,
-      contractVersion: "3.9",
-      cliVersion: "0.27.0",
+      contractVersion: "3.10",
+      cliVersion: "0.28.0",
       projectFileUploadBatchSize: 32,
       documentRecords: {
         member: {
@@ -105054,8 +106226,8 @@ function selectedSpecPaths(workspace, selectors) {
   const selectedPaths = all.filter((absolutePath) => {
     const path = relativePaths.get(absolutePath);
     const configured = configuredIncludes.length === 0 || configuredIncludes.some((pattern) => globMatches(pattern, path));
-    const selected2 = normalizedSelectors.length === 0 || normalizedSelectors.some((selector) => selectorMatches(selector, path));
-    return configured && selected2 && !(workspace.config.test?.exclude ?? []).some(
+    const selected = normalizedSelectors.length === 0 || normalizedSelectors.some((selector) => selectorMatches(selector, path));
+    return configured && selected && !(workspace.config.test?.exclude ?? []).some(
       (pattern) => globMatches(pattern.replaceAll("\\", "/"), path)
     );
   });
@@ -105256,22 +106428,22 @@ function registerSpec(spec, document) {
   );
   return { spec, root, tests };
 }
-function mockResponse(environment, mock, selected2, call) {
-  if (selected2 === null) {
+function mockResponse(environment, mock, selected, call) {
+  if (selected === null) {
     if (mock.callThrough) return { handled: false };
     throw new NeoTestAssertionError(
       `Mock for Function '${mock.memberId}' has no configured behavior. Add returns, throws, doesNothing, or implementation.`
     );
   }
-  if (selected2.kind === "throw") {
-    throw new NSGetterRuntimeError(selected2.message);
+  if (selected.kind === "throw") {
+    throw new NSGetterRuntimeError(selected.message);
   }
-  if (selected2.kind === "implementation") {
+  if (selected.kind === "implementation") {
     return {
       handled: true,
       value: call.invokeDelegate(
         bindNeoScriptDelegateToContext(
-          selected2.delegate,
+          selected.delegate,
           environment.context
         ),
         mock.isStatic ? call.args : [call.receiver, ...call.args]
@@ -105280,7 +106452,7 @@ function mockResponse(environment, mock, selected2, call) {
   }
   return {
     handled: true,
-    value: selected2.kind === "return" ? selected2.value : null
+    value: selected.kind === "return" ? selected.value : null
   };
 }
 function partialObjectMatch(actual, expected) {
@@ -105297,16 +106469,16 @@ function matchingMock(environment, call) {
     (candidate) => candidate.receiverValueId !== void 0
   );
   const receiverValueId = needsReceiverLookup ? mockReceiverValueId(environment, call.receiver) : null;
-  let selected2;
+  let selected;
   for (const candidate of candidates) {
     if (candidate.receiverValueId !== void 0 && candidate.receiverValueId !== receiverValueId) {
       continue;
     }
-    if (selected2 === void 0 || candidate.id > selected2.id) {
-      selected2 = candidate;
+    if (selected === void 0 || candidate.id > selected.id) {
+      selected = candidate;
     }
   }
-  return selected2;
+  return selected;
 }
 function mockReceiverValueId(environment, receiver) {
   if (typeof receiver !== "object" || receiver === null) return null;
@@ -105651,15 +106823,15 @@ function failureFor(error, file, position, member = null) {
     ]
   };
 }
-function suiteHasSelectedTests(suite, selected2) {
-  return suite.tests.some((test) => selected2.has(test.id)) || suite.suites.some((child) => suiteHasSelectedTests(child, selected2));
+function suiteHasSelectedTests(suite, selected) {
+  return suite.tests.some((test) => selected.has(test.id)) || suite.suites.some((child) => suiteHasSelectedTests(child, selected));
 }
-async function executeRegisteredSpec(registered, document, selected2, timeoutMs, interrupted) {
+async function executeRegisteredSpec(registered, document, selected, timeoutMs, interrupted) {
   const results = [];
   const fileFailures = [];
   let testDurationMs = 0;
   const executeSuite = async (suite, parentEnvironment, inheritedFailures) => {
-    if (!suiteHasSelectedTests(suite, selected2)) return;
+    if (!suiteHasSelectedTests(suite, selected)) return;
     const fixture = cloneTestEnvironment(parentEnvironment);
     const suiteFailures = [...inheritedFailures];
     const suiteDeadline = Date.now() + timeoutMs;
@@ -105676,7 +106848,7 @@ async function executeRegisteredSpec(registered, document, selected2, timeoutMs,
       }
     }
     for (const test of suite.tests) {
-      if (!selected2.has(test.id)) continue;
+      if (!selected.has(test.id)) continue;
       const started = performance.now();
       const deadline = Date.now() + timeoutMs;
       const environment = cloneTestEnvironment(fixture);
@@ -109864,7 +111036,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.0");
+    console.log("0.28.0");
     return;
   }
   if (args.command === null || args.command === "help" || args.command === "--help" || args.command === "-h") {