Function tryFinalizeSequence

src/compute-engine/sequence.ts:592–646

* Try to finalize a sequence definition. * A sequence is finalized when both base case(s) and recurrence are present.

(ce: ComputeEngine, name: string)

  const pending = getOrCreatePending(ce, name);
  pending.recurrence = { variables, latex: serializeLatex(expr.json) };
  pending.isMultiIndex = true;
  tryFinalizeSequence(ce, name);
}

/**
 * Try to finalize a sequence definition.
 * A sequence is finalized when both base case(s) and recurrence are present.
 */
function tryFinalizeSequence(ce: ComputeEngine, name: string): void {
  const pending = getOrCreatePending(ce, name);

  // Need both base case(s) and recurrence to finalize
  if (pending.base.size === 0 || !pending.recurrence) return;

  // Convert to SequenceDefinition format
  const base: Record<number | string, Expression> = {};
  for (const [k, v] of pending.base) {
    base[k] = v;
  }

  // Build definition based on single vs multi-index
  const def: SequenceDefinition = {
    base,
    recurrence: pending.recurrence.latex, // Pass as string for fresh parsing
  };

  if (pending.isMultiIndex || pending.recurrence.variables) {
    // Multi-index sequence
    def.variables = pending.recurrence.variables;
  } else {
    // Single-index sequence
    def.variable = pending.recurrence.variable;
  }

  // Validate the definition
  const validation = validateSequenceDefinition(ce, name, def);
  if (!validation.valid) {
    throw new Error(validation.error);
  }

  // Create the subscriptEvaluate handler
  const handler = createSequenceHandler(ce, name, def);

  // Check if the symbol already exists in the current scope
  // (it may have been auto-declared when parsing the recurrence expression)
  const scope = ce.context.lexicalScope;
  const existingDef = scope.bindings.get(name);

  if (existingDef) {
    // Symbol already exists - update it with subscriptEvaluate
    const callableBefore = defIsCallableShaped(existingDef);
    updateDef(ce, name, existingDef, {
      subscriptEvaluate: handler,
    });
    // In-place redefinition of an existing binding is a semantic mutation
    // (a structural change, not a value write: the epoch bumps too).
    ce._noteStateEvent({
      kind: 'redefine',