@neocompose/cli 0.5.3 → 0.6.0

package/dist/neo.mjs

@@ -829,6 +829,7 @@ var init_document_contracts = __esm({
           "isStatic",
           "isVirtual",
           "isAbstract",
+          "accessModifierKind",
           "defaultValue",
           "extendsMemberId",
           "system",
@@ -1185,9 +1186,29 @@ function normalizeDocumentFields(recordKind, value) {
     }
     if (current === void 0) normalized[field] = null;
   }
+  if (recordKind === "member") {
+    normalizeTypeInfoBindings(normalized.returnTypeInfo);
+    if (Array.isArray(normalized.argumentTypes)) {
+      for (const argument2 of normalized.argumentTypes) {
+        normalizeTypeInfoBindings(argument2);
+      }
+    }
+  }
   omitRedundantDeclarationOrder(recordKind, normalized);
   return normalized;
 }
+function normalizeTypeInfoBindings(value) {
+  if (!isRecord(value)) return;
+  const bindings = value.typeArguments;
+  if (bindings === null || isRecord(bindings) && Object.keys(bindings).length === 0) {
+    delete value.typeArguments;
+  } else if (isRecord(bindings)) {
+    for (const binding of Object.values(bindings)) {
+      normalizeTypeInfoBindings(binding);
+    }
+  }
+  normalizeTypeInfoBindings(value.entryTypeInfo);
+}
 function memberDefaultApplies(field, type) {
   if (field === "isVirtual" || field === "isAbstract" || field === "locked" || field === "required") {
     return true;
@@ -1508,6 +1529,11 @@ function memberFromDocument(record3, members, owners, classNames, context) {
     owner: owners.get(record3.recordId) ?? { kind: "loose" },
     name: requiredString(data, "name", record3),
     isStatic: booleanValue(data.isStatic, record3, "isStatic"),
+    accessModifier: accessModifierValue(
+      data.accessModifierKind,
+      record3,
+      "accessModifierKind"
+    ),
     modifier,
     locked: booleanValue(field("locked", false), record3, "locked"),
     required: booleanValue(field("required", false), record3, "required"),
@@ -1750,7 +1776,8 @@ function memberToDocumentFields(member, baseData3) {
     kind,
     locked: member.locked,
     required: member.required,
-    isStatic: member.isStatic
+    isStatic: member.isStatic,
+    accessModifierKind: member.accessModifier
   };
   applyModifier(fields, member, baseData3);
   if (member.defaultValue !== null) {
@@ -2350,6 +2377,16 @@ function optionalNumberOrNull(value, record3, path) {
   if (value === void 0 || value === null) return null;
   return requiredNumberValue(value, record3, path);
 }
+function accessModifierValue(value, record3, path) {
+  if (value !== "public" && value !== "protected" && value !== "private") {
+    throw invalidDocument(
+      record3,
+      path,
+      "must be public, protected, or private"
+    );
+  }
+  return value;
+}
 function requiredString(value, key, record3) {
   return requiredStringValue(value[key], record3, key);
 }
@@ -2606,6 +2643,11 @@ function interfaceFromDocument(record3, context) {
       );
       const memberId = requiredString(member, "id", record3);
       const memberSource = nestedSource(source, "interfaceMember", memberId);
+      const accessModifier = accessModifierValue(
+        member.accessModifierKind,
+        record3,
+        `members.${name}.accessModifierKind`
+      );
       if (member.kind === "property") {
         return {
           id: memberId,
@@ -2621,6 +2663,7 @@ function interfaceFromDocument(record3, context) {
             record3,
             `members.${name}.settable`
           ),
+          accessModifier,
           source: memberSource
         };
       }
@@ -2644,6 +2687,7 @@ function interfaceFromDocument(record3, context) {
             record3,
             `members.${name}.deferred`
           ),
+          accessModifier,
           source: memberSource
         };
       }
@@ -2663,7 +2707,8 @@ function interfaceToDocument(neoInterface) {
         id: member.id,
         kind: "property",
         typeInfo: manifestTypeToDocument(member.type),
-        settable: member.settable
+        settable: member.settable,
+        accessModifierKind: member.accessModifier
       };
     } else {
       members[member.name] = {
@@ -2674,7 +2719,8 @@ function interfaceToDocument(neoInterface) {
           name: argument2.name,
           ...manifestTypeToDocument(argument2.type)
         })),
-        deferred: member.deferred
+        deferred: member.deferred,
+        accessModifierKind: member.accessModifier
       };
     }
   }
@@ -3460,6 +3506,9 @@ var init_language_spec = __esm({
       "interface",
       "native",
       "override",
+      "private",
+      "protected",
+      "public",
       "return",
       "sealed",
       "static",
@@ -3759,6 +3808,66 @@ function createProjectIndex(project) {
     indexesByListMemberId
   };
 }
+function memberAccessFailure(args) {
+  const access = args.symbol.accessModifier;
+  if (access === void 0) return null;
+  if (access === "public") return null;
+  const declaringTypeId = args.symbol.inheritedFrom?.typeId ?? args.owner.id;
+  const declaringTypeName = args.symbol.inheritedFrom?.typeName ?? args.owner.name;
+  const accessing = args.context.declaringType ?? args.context.thisClass;
+  const accessingTypeId = accessing?.kind === "named" ? accessing.typeId : void 0;
+  if (access === "private") {
+    if (accessingTypeId === declaringTypeId) return null;
+    return { kind: "private", declaringTypeName };
+  }
+  if (args.owner.kind === "interface") {
+    if (accessingTypeId !== void 0 && classFamilyImplementsInterface(
+      args.project,
+      accessingTypeId,
+      declaringTypeId
+    )) {
+      return null;
+    }
+    return { kind: "interfaceProtected", interfaceName: declaringTypeName };
+  }
+  if (accessingTypeId !== void 0 && typeExtendsInclusive(args.project, accessingTypeId, declaringTypeId)) {
+    return null;
+  }
+  return { kind: "protected", declaringTypeName };
+}
+function typeExtendsInclusive(project, typeId, ancestorTypeId) {
+  const visited = /* @__PURE__ */ new Set();
+  const queue = [typeId];
+  while (queue.length > 0) {
+    const current = queue.shift();
+    if (current === ancestorTypeId) return true;
+    if (visited.has(current)) continue;
+    visited.add(current);
+    const type = project.typeById.get(current);
+    for (const baseTypeId of type?.baseTypeIds ?? []) queue.push(baseTypeId);
+  }
+  return false;
+}
+function classFamilyImplementsInterface(project, classTypeId, interfaceTypeId) {
+  const visitedClasses = /* @__PURE__ */ new Set();
+  const classQueue = [classTypeId];
+  while (classQueue.length > 0) {
+    const current = classQueue.shift();
+    if (visitedClasses.has(current)) continue;
+    visitedClasses.add(current);
+    const type = project.typeById.get(current);
+    if (type === void 0) continue;
+    for (const interfaceId of type.interfaceTypeIds ?? []) {
+      if (typeExtendsInclusive(project, interfaceId, interfaceTypeId)) {
+        return true;
+      }
+    }
+    for (const baseTypeId of type.baseTypeIds ?? []) {
+      classQueue.push(baseTypeId);
+    }
+  }
+  return false;
+}
 function withNullability(type, nullable) {
   return { ...type, nullable };
 }
@@ -4437,11 +4546,23 @@ function completionItemsForResolution(snapshot, resolved, word) {
     return resolved.staticType.members.filter((member) => member.kind === "enumMember").map((member) => symbolCompletion(member, word, snapshot));
   }
   if (resolved.staticType) {
-    return resolved.staticType.members.filter((member) => member.static === true).map((member) => symbolCompletion(member, word, snapshot));
-  }
-  return membersForType(snapshot, resolved.type).map(
-    (symbol) => symbolCompletion(symbol, word, snapshot)
-  );
+    const staticType = resolved.staticType;
+    return staticType.members.filter(
+      (member) => member.static === true && isMemberCompletionAccessible(snapshot, staticType, member)
+    ).map((member) => symbolCompletion(member, word, snapshot));
+  }
+  const owner = resolved.type.kind === "named" ? snapshot.project.typeById.get(resolved.type.typeId) : void 0;
+  return membersForType(snapshot, resolved.type).filter(
+    (symbol) => owner === void 0 || isMemberCompletionAccessible(snapshot, owner, symbol)
+  ).map((symbol) => symbolCompletion(symbol, word, snapshot));
+}
+function isMemberCompletionAccessible(snapshot, owner, symbol) {
+  return memberAccessFailure({
+    project: snapshot.project,
+    context: snapshot.context,
+    owner,
+    symbol
+  }) === null;
 }
 function membersForType(snapshot, type) {
   if (type.kind === "named") {
@@ -9788,6 +9909,7 @@ var init_strict_resolver = __esm({
                 pos
               );
             }
+            this.assertMemberAccessible(staticType, member, pos);
             if (member.static !== true) {
               throw new CompileError(
                 `Member '${staticType.name}.${name}' requires an instance receiver.`,
@@ -9940,6 +10062,7 @@ var init_strict_resolver = __esm({
               pos
             );
           }
+          this.assertMemberAccessible(type, member, pos);
           if (member.static === true) {
             throw new CompileError(
               `Static member '${type.name}.${name}' must be accessed through the type name, not an instance.`,
@@ -10261,6 +10384,7 @@ var init_strict_resolver = __esm({
                 pos
               );
             }
+            this.assertMemberAccessible(staticType, member, pos);
             if (member.static !== true) {
               throw new CompileError(
                 `Member '${staticType.name}.${callee.name}' requires an instance receiver.`,
@@ -10297,6 +10421,7 @@ var init_strict_resolver = __esm({
             (candidate) => (candidate.kind === "function" || candidate.kind === "method") && candidate.name === callee.name
           );
           if (member) {
+            if (type !== void 0) this.assertMemberAccessible(type, member, pos);
             if (member.static === true) {
               throw new CompileError(
                 `Static member '${type?.name}.${callee.name}' must be accessed through the type name, not an instance.`,
@@ -10847,6 +10972,7 @@ var init_strict_resolver = __esm({
               (candidate) => (candidate.kind === "function" || candidate.kind === "method") && candidate.name === memberName
             );
             if (!symbol2) return null;
+            this.assertMemberAccessible(staticType, symbol2, expression.pos);
             if (symbol2.static !== true) {
               throw new CompileError(
                 `Member '${staticType.name}.${memberName}' requires an instance receiver.`,
@@ -10888,6 +11014,9 @@ var init_strict_resolver = __esm({
           (candidate) => (candidate.kind === "function" || candidate.kind === "method") && candidate.name === memberName
         );
         if (!symbol) return null;
+        if (type !== void 0) {
+          this.assertMemberAccessible(type, symbol, expression.pos);
+        }
         if (symbol.static === true) {
           throw new CompileError(
             `Static member '${type?.name}.${memberName}' must be accessed through the type name, not an instance.`,
@@ -11265,6 +11394,36 @@ var init_strict_resolver = __esm({
       describe(type) {
         return formatType(type, this.project);
       }
+      /**
+       * Enforces C#-style member accessibility on a resolved member. Runs after
+       * the member is found so hover/definition still resolve while the strict
+       * compile carries the diagnostic.
+       */
+      assertMemberAccessible(owner, symbol, pos) {
+        const failure = memberAccessFailure({
+          project: this.project,
+          context: this.context,
+          owner,
+          symbol
+        });
+        if (failure === null) return;
+        if (failure.kind === "private") {
+          throw new CompileError(
+            `'${symbol.name}' is private to ${failure.declaringTypeName}.`,
+            pos
+          );
+        }
+        if (failure.kind === "interfaceProtected") {
+          throw new CompileError(
+            `'${symbol.name}' is protected; through an ${failure.interfaceName} reference it is accessible only from classes that implement ${failure.interfaceName} and their derived classes.`,
+            pos
+          );
+        }
+        throw new CompileError(
+          `'${symbol.name}' is protected; accessible only from ${failure.declaringTypeName} and derived classes.`,
+          pos
+        );
+      }
       symbolValue(symbol) {
         if (symbol.kind === "root" || symbol.kind === "parameter" || symbol.kind === "value") {
           return {
@@ -11287,6 +11446,13 @@ var init_strict_resolver = __esm({
         if (this.context.staticMember === true && symbol.static !== true) {
           return null;
         }
+        const accessFailure = memberAccessFailure({
+          project: this.project,
+          context: this.context,
+          owner,
+          symbol
+        });
+        if (accessFailure !== null) return null;
         return { owner, symbol };
       }
       nextCallSite(pos) {
@@ -12335,12 +12501,165 @@ var init_parity_contract = __esm({
 });
 
 // ../packages/neoscript-language/src/project-source-ast.ts
+function isNeoSourceAccessModifier(value) {
+  return value === "public" || value === "protected" || value === "private";
+}
+function effectiveSourceAccessModifier(modifiers, ownerKind) {
+  const explicit = modifiers.find(isNeoSourceAccessModifier);
+  if (explicit !== void 0) return explicit;
+  return ownerKind === "interface" ? "public" : "private";
+}
 var init_project_source_ast = __esm({
   "../packages/neoscript-language/src/project-source-ast.ts"() {
     "use strict";
   }
 });
 
+// ../packages/neoscript-language/src/project-source-tokens.ts
+function rangeContains(range2, position) {
+  return positionCompare(range2.start, position) <= 0 && positionCompare(position, range2.end) <= 0;
+}
+function rangeSize(range2) {
+  return (range2.end.line - range2.start.line) * 1e6 + range2.end.character - range2.start.character;
+}
+function documentPrefix(text, position) {
+  const lines = text.split("\n");
+  return [
+    ...lines.slice(0, position.line),
+    (lines[position.line] ?? "").slice(0, position.character)
+  ].join("\n");
+}
+function projectTokenAt(document, position) {
+  const offset = new SourceText(document.text).offsetAt(position);
+  const tokens = projectTokens(document);
+  const containing = tokens.find(
+    (token) => token.start <= offset && offset < token.end
+  );
+  if (containing?.kind === "identifier") return containing;
+  const touching = tokens.find(
+    (token) => token.kind === "identifier" && token.end === offset
+  );
+  return touching ?? containing;
+}
+function projectTokens(document) {
+  const cached = PROJECT_TOKEN_CACHE.get(document);
+  if (cached) return cached;
+  const source = new SourceText(document.text);
+  const tokens = lex(document.text).tokens.flatMap(
+    (token) => {
+      if (token.kind !== "string" || !token.raw.startsWith('"""')) {
+        return [token];
+      }
+      const result = [];
+      const contentEnd = token.raw.endsWith('"""') ? token.end - 3 : token.end;
+      let segmentStart = token.start;
+      let cursor = token.start + 3;
+      while (cursor < contentEnd) {
+        if (document.text[cursor] !== "{" || document.text[cursor + 1] === "{") {
+          cursor++;
+          continue;
+        }
+        const close = tripleInterpolationEnd(
+          document.text,
+          cursor + 1,
+          contentEnd
+        );
+        if (close === null) break;
+        if (segmentStart < cursor + 1) {
+          result.push(
+            projectToken(
+              "string",
+              document.text,
+              source,
+              segmentStart,
+              cursor + 1
+            )
+          );
+        }
+        const expressionStart = cursor + 1;
+        const expression = document.text.slice(expressionStart, close);
+        for (const nested of lex(expression).tokens) {
+          if (nested.kind === "eof") continue;
+          const start = expressionStart + nested.start;
+          const end = expressionStart + nested.end;
+          result.push({
+            ...nested,
+            start,
+            end,
+            raw: document.text.slice(start, end),
+            range: source.range(start, end)
+          });
+        }
+        segmentStart = close;
+        cursor = close + 1;
+      }
+      if (segmentStart < token.end) {
+        result.push(
+          projectToken(
+            "string",
+            document.text,
+            source,
+            segmentStart,
+            token.end
+          )
+        );
+      }
+      return result;
+    }
+  );
+  PROJECT_TOKEN_CACHE.set(document, tokens);
+  return tokens;
+}
+function projectToken(kind, text, source, start, end) {
+  const raw = text.slice(start, end);
+  return { kind, text: raw, raw, start, end, range: source.range(start, end) };
+}
+function tripleInterpolationEnd(text, start, limit) {
+  let depth = 0;
+  let cursor = start;
+  while (cursor < limit) {
+    const char = text[cursor];
+    const next = text[cursor + 1];
+    if (char === '"') {
+      cursor++;
+      while (cursor < limit) {
+        if (text[cursor] === "\\") cursor += 2;
+        else if (text[cursor] === '"') {
+          cursor++;
+          break;
+        } else cursor++;
+      }
+      continue;
+    }
+    if (char === "/" && next === "/") {
+      while (cursor < limit && text[cursor] !== "\n") cursor++;
+      continue;
+    }
+    if (char === "{") depth++;
+    else if (char === "}") {
+      if (depth === 0) return cursor;
+      depth--;
+    }
+    cursor++;
+  }
+  return null;
+}
+function rangesEqual(left, right) {
+  return positionCompare(left.start, right.start) === 0 && positionCompare(left.end, right.end) === 0;
+}
+function positionCompare(left, right) {
+  return left.line === right.line ? left.character - right.character : left.line - right.line;
+}
+var PROJECT_TOKEN_CACHE;
+var init_project_source_tokens = __esm({
+  "../packages/neoscript-language/src/project-source-tokens.ts"() {
+    "use strict";
+    init_lexer();
+    init_source_text();
+    PROJECT_TOKEN_CACHE = /* @__PURE__ */ new WeakMap();
+  }
+});
+
 // ../packages/neoscript-language/src/project-source-parser.ts
 function parseNeoProjectSource(sourceValue, kind) {
   const lexed = lex(sourceValue);
@@ -12657,6 +12976,7 @@ function validateDeclarationSemantics(declarations, diagnostics) {
           message: `Member '${member.name}' repeats the '${modifier}' modifier.`
         });
       }
+      validateMemberAccessModifiers(declaration, member, diagnostics);
       if (member.kind !== "function") continue;
       if (declaration.kind === "interface") {
         if (member.body) {
@@ -12702,6 +13022,61 @@ function validateDeclarationSemantics(declarations, diagnostics) {
     }
   }
 }
+function validateMemberAccessModifiers(declaration, member, diagnostics) {
+  const accessModifiers = [
+    ...new Set(member.modifiers.filter(isNeoSourceAccessModifier))
+  ];
+  if (accessModifiers.length > 1) {
+    diagnostics.push({
+      range: member.nameRange,
+      severity: "error",
+      source: "neo-project",
+      code: "conflicting-access-modifiers",
+      message: `Member '${member.name}' declares more than one access modifier (${accessModifiers.join(", ")}); a member accepts at most one.`
+    });
+    return;
+  }
+  const accessModifier = accessModifiers[0];
+  if (accessModifier === void 0) return;
+  if (declaration.kind === "interface" && accessModifier === "private") {
+    diagnostics.push({
+      range: member.nameRange,
+      severity: "error",
+      source: "neo-project",
+      code: "private-interface-member",
+      message: `Interface member '${member.name}' cannot be private; private interface members are not yet supported. Use public or protected.`
+    });
+    return;
+  }
+  if (accessModifier !== "private") return;
+  if (member.modifiers.includes("virtual")) {
+    diagnostics.push({
+      range: member.nameRange,
+      severity: "error",
+      source: "neo-project",
+      code: "private-virtual-member",
+      message: `Member '${member.name}' cannot be both private and virtual; a private member is never overridable.`
+    });
+  }
+  if (member.modifiers.includes("abstract")) {
+    diagnostics.push({
+      range: member.nameRange,
+      severity: "error",
+      source: "neo-project",
+      code: "private-abstract-member",
+      message: `Member '${member.name}' cannot be both private and abstract; an abstract member exists to be implemented by descendants.`
+    });
+  }
+  if (member.modifiers.includes("override")) {
+    diagnostics.push({
+      range: member.nameRange,
+      severity: "error",
+      source: "neo-project",
+      code: "private-override-member",
+      message: `Member '${member.name}' cannot be both private and override; an override keeps the accessibility of the member it overrides, and a private member cannot be overridden.`
+    });
+  }
+}
 function isNameToken(token) {
   return token !== void 0 && (token.kind === "identifier" || token.kind === "type" || token.kind === "keyword");
 }
@@ -12737,12 +13112,16 @@ var init_project_source_parser = __esm({
     "use strict";
     init_lexer();
     init_neoflow_graph_parser();
+    init_project_source_ast();
     init_source_text();
     MODIFIERS = /* @__PURE__ */ new Set([
       "abstract",
       "async",
       "native",
       "override",
+      "private",
+      "protected",
+      "public",
       "sealed",
       "static",
       "virtual"
@@ -12780,6 +13159,14 @@ var init_project_source_parser = __esm({
         const annotations = this.parseAnnotations();
         const modifiers = this.parseModifiers();
         if (this.at("class")) {
+          const accessModifier = modifiers.find(isNeoSourceAccessModifier);
+          if (accessModifier !== void 0) {
+            throw this.failure(
+              "source-class-access-modifier",
+              `Access modifier '${accessModifier}' is valid only on class and interface member declarations, not on a class declaration.`,
+              start
+            );
+          }
           return this.parseClass(start, annotations, modifiers);
         }
         if (this.at("interface")) {
@@ -13380,6 +13767,7 @@ var init_project_schema_contract_generated = __esm({
           "isStatic",
           "isVirtual",
           "isAbstract",
+          "accessModifierKind",
           "defaultValue",
           "extendsMemberId",
           "system",
@@ -17191,6 +17579,10 @@ function sourceMemberSymbol(member, owner, typeIds, source) {
     type,
     static: staticMember,
     abstract: member.modifiers.includes("abstract"),
+    accessModifier: effectiveSourceAccessModifier(
+      member.modifiers,
+      owner.declaration.kind
+    ),
     location: location(owner.uri, member.range),
     selectionLocation: location(owner.uri, member.nameRange)
   };
@@ -17525,6 +17917,7 @@ var init_project_source_script_compiler = __esm({
     "use strict";
     init_compiler();
     init_language_spec();
+    init_project_source_ast();
     init_project();
     init_project_root();
     init_source_text();
@@ -18081,6 +18474,7 @@ function validateMembers(environment, diagnostics) {
       }
       for (const modifier of member.modifiers) {
         if (modifier === "async" && member.kind === "function") continue;
+        if (isNeoSourceAccessModifier(modifier)) continue;
         diagnose(
           diagnostics,
           ref.uri,
@@ -18734,6 +19128,7 @@ var init_project_source_type_checker = __esm({
   "../packages/neoscript-language/src/project-source-type-checker.ts"() {
     "use strict";
     init_language_spec();
+    init_project_source_ast();
     BUILTIN_ARITY = /* @__PURE__ */ new Map([
       ["List", 1],
       ["Set", 1],
@@ -18792,7 +19187,13 @@ function analyzeNeoProjectSources(inputs) {
   const symbols = [];
   for (const [uri, document] of documents) {
     for (const declaration of document.declarations) {
-      collectDeclarationSymbols(uri, declaration, symbols, diagnostics);
+      collectDeclarationSymbols(
+        uri,
+        document,
+        declaration,
+        symbols,
+        diagnostics
+      );
     }
   }
   validateSymbolUniqueness(symbols, diagnostics);
@@ -18802,7 +19203,7 @@ function analyzeNeoProjectSources(inputs) {
   diagnostics.push(...compileProjectSourceBodies(documents).diagnostics);
   return { documents, symbols, diagnostics };
 }
-function collectDeclarationSymbols(uri, declaration, symbols, diagnostics) {
+function collectDeclarationSymbols(uri, document, declaration, symbols, diagnostics) {
   const declarationKind = declaration.kind;
   collectSymbol(
     uri,
@@ -18812,7 +19213,9 @@ function collectDeclarationSymbols(uri, declaration, symbols, diagnostics) {
     declaration.annotations,
     void 0,
     symbols,
-    diagnostics
+    diagnostics,
+    void 0,
+    declaration.kind === "global" ? declaration.type.name : void 0
   );
   if (declaration.kind === "enum") {
     for (const option of declaration.options) {
@@ -18829,7 +19232,10 @@ function collectDeclarationSymbols(uri, declaration, symbols, diagnostics) {
     }
     return;
   }
-  if (declaration.kind === "global") return;
+  if (declaration.kind === "global") {
+    collectGlobalChildSymbols(uri, document, declaration, symbols, diagnostics);
+    return;
+  }
   if (declaration.kind === "class") {
     for (const parameter3 of declaration.genericParameters) {
       collectSymbol(
@@ -18886,6 +19292,104 @@ function collectDeclarationSymbols(uri, declaration, symbols, diagnostics) {
     }
   }
 }
+function collectGlobalChildSymbols(uri, document, declaration, symbols, diagnostics) {
+  if (declaration.type.name === "Root") return;
+  const initializer = declaration.initializer;
+  const tokens = lex(document.sourceText).tokens.filter(
+    (token) => token.kind !== "comment" && token.kind !== "eof" && rangeWithin(initializer.range, token.range)
+  );
+  let braceDepth = 0;
+  let groupDepth = 0;
+  let pendingAnnotations = [];
+  for (let index = 0; index < tokens.length; index++) {
+    const token = tokens[index];
+    if (token.text === "{") {
+      braceDepth++;
+      continue;
+    }
+    if (token.text === "}") {
+      braceDepth--;
+      continue;
+    }
+    if (braceDepth !== 1) continue;
+    if (token.text === "(" || token.text === "[") {
+      groupDepth++;
+      continue;
+    }
+    if (token.text === ")" || token.text === "]") {
+      groupDepth--;
+      continue;
+    }
+    if (groupDepth !== 0) continue;
+    if (token.text === ";") {
+      pendingAnnotations = [];
+      continue;
+    }
+    if (token.text === "@") {
+      const annotation2 = scanAnnotation(tokens, index);
+      if (annotation2) {
+        pendingAnnotations.push(annotation2.annotation);
+        index = annotation2.endIndex;
+      }
+      continue;
+    }
+    const name = tokens[index + 1];
+    if ((token.kind === "type" || token.kind === "identifier") && name?.kind === "identifier" && tokens[index + 2]?.text === "=" && tokens[index + 3]?.text !== "=" && // A pending annotation or statement boundary precedes a declaration;
+    // `key: value` fields and expression member accesses never do.
+    tokens[index - 1]?.text !== "." && tokens[index - 1]?.text !== ":") {
+      collectSymbol(
+        uri,
+        "graphChild",
+        name.text,
+        name.range,
+        pendingAnnotations,
+        declaration.name,
+        symbols,
+        diagnostics,
+        void 0,
+        token.text
+      );
+      pendingAnnotations = [];
+      index += 2;
+    }
+  }
+}
+function scanAnnotation(tokens, atIndex) {
+  const marker = tokens[atIndex];
+  const name = tokens[atIndex + 1];
+  if (!name || name.kind !== "identifier" && name.kind !== "keyword") {
+    return null;
+  }
+  const argumentsList2 = [];
+  let endIndex = atIndex + 1;
+  let endRange = name.range;
+  if (tokens[atIndex + 2]?.text === "(") {
+    let depth = 0;
+    for (let index = atIndex + 2; index < tokens.length; index++) {
+      const token = tokens[index];
+      if (token.text === "(") depth++;
+      else if (token.text === ")" && --depth === 0) {
+        endIndex = index;
+        endRange = token.range;
+        break;
+      } else if (depth === 1 && token.kind === "string") {
+        argumentsList2.push({ text: token.raw, range: token.range });
+      }
+    }
+  }
+  return {
+    annotation: {
+      name: name.text,
+      nameRange: name.range,
+      arguments: argumentsList2,
+      range: { start: marker.range.start, end: endRange.end }
+    },
+    endIndex
+  };
+}
+function rangeWithin(outer, inner) {
+  return positionCompare(outer.start, inner.start) <= 0 && positionCompare(inner.end, outer.end) <= 0;
+}
 function collectFlowSymbols(uri, content, ownerName, scopeRange, symbols, diagnostics) {
   for (const binding of content.bindings) {
     collectSymbol(
@@ -19177,6 +19681,8 @@ var init_project_source_analysis = __esm({
   "../packages/neoscript-language/src/project-source-analysis.ts"() {
     "use strict";
     init_language_spec();
+    init_lexer();
+    init_project_source_tokens();
     init_project_source_parser();
     init_project_source_semantics();
     init_project_source_script_compiler();
@@ -21242,151 +21748,6 @@ var init_project_schema_manifest = __esm({
   }
 });
 
-// ../packages/neoscript-language/src/project-source-tokens.ts
-function rangeContains(range2, position) {
-  return positionCompare(range2.start, position) <= 0 && positionCompare(position, range2.end) <= 0;
-}
-function rangeSize(range2) {
-  return (range2.end.line - range2.start.line) * 1e6 + range2.end.character - range2.start.character;
-}
-function documentPrefix(text, position) {
-  const lines = text.split("\n");
-  return [
-    ...lines.slice(0, position.line),
-    (lines[position.line] ?? "").slice(0, position.character)
-  ].join("\n");
-}
-function projectTokenAt(document, position) {
-  const offset = new SourceText(document.text).offsetAt(position);
-  const tokens = projectTokens(document);
-  const containing = tokens.find(
-    (token) => token.start <= offset && offset < token.end
-  );
-  if (containing?.kind === "identifier") return containing;
-  const touching = tokens.find(
-    (token) => token.kind === "identifier" && token.end === offset
-  );
-  return touching ?? containing;
-}
-function projectTokens(document) {
-  const cached = PROJECT_TOKEN_CACHE.get(document);
-  if (cached) return cached;
-  const source = new SourceText(document.text);
-  const tokens = lex(document.text).tokens.flatMap(
-    (token) => {
-      if (token.kind !== "string" || !token.raw.startsWith('"""')) {
-        return [token];
-      }
-      const result = [];
-      const contentEnd = token.raw.endsWith('"""') ? token.end - 3 : token.end;
-      let segmentStart = token.start;
-      let cursor = token.start + 3;
-      while (cursor < contentEnd) {
-        if (document.text[cursor] !== "{" || document.text[cursor + 1] === "{") {
-          cursor++;
-          continue;
-        }
-        const close = tripleInterpolationEnd(
-          document.text,
-          cursor + 1,
-          contentEnd
-        );
-        if (close === null) break;
-        if (segmentStart < cursor + 1) {
-          result.push(
-            projectToken(
-              "string",
-              document.text,
-              source,
-              segmentStart,
-              cursor + 1
-            )
-          );
-        }
-        const expressionStart = cursor + 1;
-        const expression = document.text.slice(expressionStart, close);
-        for (const nested of lex(expression).tokens) {
-          if (nested.kind === "eof") continue;
-          const start = expressionStart + nested.start;
-          const end = expressionStart + nested.end;
-          result.push({
-            ...nested,
-            start,
-            end,
-            raw: document.text.slice(start, end),
-            range: source.range(start, end)
-          });
-        }
-        segmentStart = close;
-        cursor = close + 1;
-      }
-      if (segmentStart < token.end) {
-        result.push(
-          projectToken(
-            "string",
-            document.text,
-            source,
-            segmentStart,
-            token.end
-          )
-        );
-      }
-      return result;
-    }
-  );
-  PROJECT_TOKEN_CACHE.set(document, tokens);
-  return tokens;
-}
-function projectToken(kind, text, source, start, end) {
-  const raw = text.slice(start, end);
-  return { kind, text: raw, raw, start, end, range: source.range(start, end) };
-}
-function tripleInterpolationEnd(text, start, limit) {
-  let depth = 0;
-  let cursor = start;
-  while (cursor < limit) {
-    const char = text[cursor];
-    const next = text[cursor + 1];
-    if (char === '"') {
-      cursor++;
-      while (cursor < limit) {
-        if (text[cursor] === "\\") cursor += 2;
-        else if (text[cursor] === '"') {
-          cursor++;
-          break;
-        } else cursor++;
-      }
-      continue;
-    }
-    if (char === "/" && next === "/") {
-      while (cursor < limit && text[cursor] !== "\n") cursor++;
-      continue;
-    }
-    if (char === "{") depth++;
-    else if (char === "}") {
-      if (depth === 0) return cursor;
-      depth--;
-    }
-    cursor++;
-  }
-  return null;
-}
-function rangesEqual(left, right) {
-  return positionCompare(left.start, right.start) === 0 && positionCompare(left.end, right.end) === 0;
-}
-function positionCompare(left, right) {
-  return left.line === right.line ? left.character - right.character : left.line - right.line;
-}
-var PROJECT_TOKEN_CACHE;
-var init_project_source_tokens = __esm({
-  "../packages/neoscript-language/src/project-source-tokens.ts"() {
-    "use strict";
-    init_lexer();
-    init_source_text();
-    PROJECT_TOKEN_CACHE = /* @__PURE__ */ new WeakMap();
-  }
-});
-
 // ../packages/neoscript-language/src/quick-fixes.ts
 function quickFixFor(document, diagnostic) {
   if (diagnostic.code === "missing-semicolon") {
@@ -21703,11 +22064,17 @@ function projectMemberCompletions(analysis, document, position) {
   if (!owner || owner.kind !== "identifier") return null;
   const resolvedOwner = projectSymbolAt(analysis, document, owner.range.start);
   if (!resolvedOwner) return null;
+  const ownerNames = /* @__PURE__ */ new Set();
   const typeName = projectSymbolTypeName(resolvedOwner.symbol);
-  if (!typeName) return null;
-  return analysis.symbols.filter(
-    (symbol) => symbol.kind === "member" && symbol.ownerName === typeName
+  if (typeName) ownerNames.add(typeName);
+  if (resolvedOwner.symbol.kind === "global") {
+    ownerNames.add(resolvedOwner.symbol.name);
+  }
+  if (ownerNames.size === 0) return null;
+  const members = analysis.symbols.filter(
+    (symbol) => (symbol.kind === "member" || symbol.kind === "graphChild") && symbol.ownerName !== void 0 && ownerNames.has(symbol.ownerName)
   );
+  return members.length > 0 ? members : null;
 }
 function projectConstructorArgumentCompletions(analysis, document, position) {
   const tokens = lex(document.text).tokens.filter(
@@ -21799,6 +22166,15 @@ function graphConstructorNamedArguments(typeName) {
         { name: "reason", type: "string" },
         { name: "duration", type: "decimal?" }
       ];
+    case "Vector2":
+    case "Vector2Int":
+    case "Vector3":
+    case "Vector3Int":
+    case "Color":
+      return graphConstructorParameters(typeName).map((parameter3) => ({
+        name: parameter3.name,
+        type: parameter3.type
+      }));
     default:
       return null;
   }
@@ -22234,6 +22610,19 @@ function indexedProjectSymbolAt(analysis, document, position, index) {
     return { token, symbol: visibleCandidates[0] };
   }
   if (visibleCandidates.length === 0) return null;
+  const sourceTokens = projectTokens(document);
+  const tokenIndex = sourceTokens.findIndex(
+    (candidate) => candidate.start === token.start && candidate.end === token.end
+  );
+  if (sourceTokens[tokenIndex + 1]?.text === "=" && sourceTokens[tokenIndex + 2]?.text !== "=") {
+    const constructed = constructionMemberSymbol(
+      analysis,
+      document,
+      token,
+      visibleCandidates
+    );
+    if (constructed) return { token, symbol: constructed };
+  }
   const source = analysis.documents.get(document.uri);
   const owner = source ? declarationContaining(source, token.range.start)?.name : void 0;
   if (owner) {
@@ -22242,10 +22631,6 @@ function indexedProjectSymbolAt(analysis, document, position, index) {
     );
     if (owned.length === 1) return { token, symbol: owned[0] };
   }
-  const sourceTokens = projectTokens(document);
-  const tokenIndex = sourceTokens.findIndex(
-    (candidate) => candidate.start === token.start && candidate.end === token.end
-  );
   const dotOwner = sourceTokens[tokenIndex - 1]?.text === "." ? sourceTokens[tokenIndex - 2] : void 0;
   if (dotOwner) {
     const resolvedOwner = indexedProjectSymbolAt(
@@ -22254,15 +22639,39 @@ function indexedProjectSymbolAt(analysis, document, position, index) {
       dotOwner.range.start,
       index
     );
-    const ownerType = resolvedOwner ? projectSymbolTypeName(resolvedOwner.symbol) : dotOwner.text;
+    const ownerNames = /* @__PURE__ */ new Set();
+    if (resolvedOwner) {
+      const typeName = projectSymbolTypeName(resolvedOwner.symbol);
+      if (typeName) ownerNames.add(typeName);
+      if (resolvedOwner.symbol.kind === "global") {
+        ownerNames.add(resolvedOwner.symbol.name);
+      }
+    } else {
+      ownerNames.add(dotOwner.text);
+    }
     const qualified = visibleCandidates.filter(
-      (symbol) => symbol.ownerName === ownerType
+      (symbol) => symbol.ownerName !== void 0 && ownerNames.has(symbol.ownerName)
     );
     if (qualified.length === 1) return { token, symbol: qualified[0] };
   }
   const projectLevel = visibleCandidates.filter((symbol) => !symbol.ownerName);
   return projectLevel.length === 1 ? { token, symbol: projectLevel[0] } : null;
 }
+function constructionMemberSymbol(analysis, document, token, candidates) {
+  const site = constructionSiteAt(analysis, document, token.range.start);
+  let current = site?.enclosingTypeName ?? null;
+  const visited = /* @__PURE__ */ new Set();
+  while (current !== null && !visited.has(current)) {
+    visited.add(current);
+    const owned = candidates.find(
+      (symbol) => symbol.kind === "member" && symbol.ownerName === current
+    );
+    if (owned) return owned;
+    const declaration = findTypeDeclaration(analysis, current);
+    current = declaration?.kind === "class" ? resolvableBaseClassName(analysis, declaration) : null;
+  }
+  return null;
+}
 function projectSymbolTypeName(symbol) {
   switch (symbol.kind) {
     case "class":
@@ -22360,24 +22769,222 @@ function signatureResult(name, parameters, activeParameter) {
   };
 }
 function contextualConstructorType(analysis, document, position) {
+  return constructionSiteAt(analysis, document, position)?.expectedTypeName ?? null;
+}
+function initializerRootAt(analysis, document, position) {
   const source = analysis.documents.get(document.uri);
   if (!source) return null;
   for (const declaration of source.declarations) {
     if (declaration.kind === "global") {
       if (rangeContains(declaration.initializer.range, position)) {
-        return declaration.type.name;
+        return {
+          type: declaration.type,
+          range: declaration.initializer.range
+        };
       }
       continue;
     }
     if (declaration.kind === "enum") continue;
     for (const member of declaration.members) {
       if (member.kind === "field" && member.initializer && rangeContains(member.initializer.range, position)) {
-        return member.type.name;
+        return { type: member.type, range: member.initializer.range };
       }
     }
   }
   return null;
 }
+function constructionSiteAt(analysis, document, position) {
+  const root = initializerRootAt(analysis, document, position);
+  if (!root) return null;
+  const tokens = projectTokens(document).filter(
+    (token) => token.kind !== "comment" && token.kind !== "eof" && rangeContains(root.range, token.range.start) && positionCompare(token.range.start, position) < 0
+  );
+  const stack = [];
+  const expectedType = () => {
+    const frame = stack.at(-1);
+    if (!frame) return root.type;
+    switch (frame.kind) {
+      case "object":
+      case "dictionary":
+        return frame.slotType;
+      case "list":
+        return frame.elementType;
+      case "call":
+        return constructorArgumentType(analysis, frame);
+      case "opaque":
+        return null;
+    }
+  };
+  let sawNew = false;
+  let pendingNewTypeName = null;
+  let closedConstructorTypeName = null;
+  for (let index = 0; index < tokens.length; index++) {
+    const token = tokens[index];
+    if (token.text === "@") {
+      if ((tokens[index + 1]?.kind === "identifier" || tokens[index + 1]?.kind === "keyword") && tokens[index + 2]?.text === "(") {
+        let depth = 0;
+        index += 2;
+        for (; index < tokens.length; index++) {
+          if (tokens[index].text === "(") depth++;
+          else if (tokens[index].text === ")" && --depth === 0) break;
+        }
+      } else if (tokens[index + 1]?.kind === "identifier") {
+        index += 1;
+      }
+      continue;
+    }
+    if (token.text === "new") {
+      sawNew = true;
+      pendingNewTypeName = expectedType()?.name ?? null;
+      closedConstructorTypeName = null;
+      continue;
+    }
+    if (sawNew && (token.kind === "identifier" || token.kind === "type")) {
+      pendingNewTypeName = token.text;
+      continue;
+    }
+    if (sawNew && token.text === "<") {
+      let depth = 0;
+      for (; index < tokens.length; index++) {
+        if (tokens[index].text === "<") depth++;
+        else if (tokens[index].text === ">" && --depth === 0) break;
+      }
+      continue;
+    }
+    if (token.text === "{") {
+      if (sawNew || closedConstructorTypeName !== null) {
+        stack.push({
+          kind: "object",
+          typeName: pendingNewTypeName ?? closedConstructorTypeName,
+          slotType: null
+        });
+        sawNew = false;
+        pendingNewTypeName = null;
+      } else {
+        const expected = expectedType();
+        if (expected?.name === "Dictionary") {
+          stack.push({
+            kind: "dictionary",
+            valueType: expected.typeArguments[1] ?? null,
+            slotType: null
+          });
+        } else {
+          stack.push({ kind: "opaque" });
+        }
+      }
+      closedConstructorTypeName = null;
+      continue;
+    }
+    if (token.text === "(") {
+      if (sawNew) {
+        stack.push({
+          kind: "call",
+          typeName: pendingNewTypeName,
+          argumentIndex: 0,
+          argumentName: null
+        });
+        sawNew = false;
+        pendingNewTypeName = null;
+      } else {
+        stack.push({ kind: "opaque" });
+      }
+      closedConstructorTypeName = null;
+      continue;
+    }
+    if (token.text === "[") {
+      stack.push({
+        kind: "list",
+        elementType: collectionElementType2(expectedType())
+      });
+      closedConstructorTypeName = null;
+      continue;
+    }
+    if (token.text === ")") {
+      const frame2 = stack.pop();
+      closedConstructorTypeName = frame2?.kind === "call" ? frame2.typeName : null;
+      continue;
+    }
+    if (token.text === "}" || token.text === "]") {
+      stack.pop();
+      closedConstructorTypeName = null;
+      continue;
+    }
+    closedConstructorTypeName = null;
+    const frame = stack.at(-1);
+    if (!frame) continue;
+    if (frame.kind === "object") {
+      if (token.text === "=" && tokens[index + 1]?.text !== "=") {
+        const nameToken = tokens[index - 1];
+        frame.slotType = nameToken && (nameToken.kind === "identifier" || nameToken.kind === "type") ? declaredFieldType(analysis, frame.typeName, nameToken.text) : null;
+      } else if (token.text === ",") {
+        frame.slotType = null;
+      }
+    } else if (frame.kind === "dictionary") {
+      if (token.text === ":") frame.slotType = frame.valueType;
+      else if (token.text === ",") frame.slotType = null;
+    } else if (frame.kind === "call") {
+      if (token.text === ",") {
+        frame.argumentIndex++;
+        frame.argumentName = null;
+      } else if (token.text === ":") {
+        const nameToken = tokens[index - 1];
+        frame.argumentName = nameToken?.kind === "identifier" ? nameToken.text : null;
+      }
+    }
+  }
+  const enclosing = [...stack].reverse().find(
+    (frame) => frame.kind === "object"
+  );
+  return {
+    expectedTypeName: expectedType()?.name ?? null,
+    enclosingTypeName: enclosing?.typeName ?? null
+  };
+}
+function collectionElementType2(type) {
+  if (!type) return null;
+  if (type.name === "List" || type.name === "Set") {
+    return type.typeArguments[0] ?? null;
+  }
+  return null;
+}
+function constructorArgumentType(analysis, frame) {
+  if (!frame.typeName) return null;
+  const declaration = findTypeDeclaration(analysis, frame.typeName);
+  if (!declaration || declaration.kind === "global" || declaration.kind === "enum") {
+    return null;
+  }
+  const fields = declaration.members.filter(
+    (member) => member.kind === "field" && !member.modifiers.includes("static")
+  );
+  if (frame.argumentName !== null) {
+    return fields.find((field) => field.name === frame.argumentName)?.type ?? null;
+  }
+  return fields[frame.argumentIndex]?.type ?? null;
+}
+function declaredFieldType(analysis, typeName, fieldName) {
+  let current = typeName;
+  const visited = /* @__PURE__ */ new Set();
+  while (current !== null && !visited.has(current)) {
+    visited.add(current);
+    const declaration = findTypeDeclaration(analysis, current);
+    if (!declaration || declaration.kind === "global" || declaration.kind === "enum") {
+      return null;
+    }
+    const member = declaration.members.find(
+      (candidate) => candidate.kind === "field" && candidate.name === fieldName
+    );
+    if (member) return member.type;
+    current = declaration.kind === "class" ? resolvableBaseClassName(analysis, declaration) : null;
+  }
+  return null;
+}
+function resolvableBaseClassName(analysis, declaration) {
+  for (const base of declaration.baseTypes) {
+    const resolved = findTypeDeclaration(analysis, base.name);
+    if (resolved?.kind === "class") return base.name;
+  }
+  return null;
+}
 function findTypeDeclaration(analysis, name) {
   for (const document of analysis.documents.values()) {
     const declaration = document.declarations.find(
@@ -22448,6 +23055,35 @@ function graphConstructorParameters(typeName) {
         { type: "string", name: "reason" },
         { type: "decimal?", name: "duration" }
       ];
+    case "Vector2":
+      return [
+        { type: "float", name: "x" },
+        { type: "float", name: "y" }
+      ];
+    case "Vector2Int":
+      return [
+        { type: "int", name: "x" },
+        { type: "int", name: "y" }
+      ];
+    case "Vector3":
+      return [
+        { type: "float", name: "x" },
+        { type: "float", name: "y" },
+        { type: "float", name: "z" }
+      ];
+    case "Vector3Int":
+      return [
+        { type: "int", name: "x" },
+        { type: "int", name: "y" },
+        { type: "int", name: "z" }
+      ];
+    case "Color":
+      return [
+        { type: "float", name: "r" },
+        { type: "float", name: "g" },
+        { type: "float", name: "b" },
+        { type: "float", name: "a" }
+      ];
     default:
       return [];
   }
@@ -23910,6 +24546,11 @@ function assertMember2(value, path) {
   assertMemberOwner(member.owner, `${path}.owner`);
   nonEmptyString(member.name, `${path}.name`);
   booleanAt(member.isStatic, `${path}.isStatic`);
+  stringIn(
+    member.accessModifier,
+    /* @__PURE__ */ new Set(["public", "protected", "private"]),
+    `${path}.accessModifier`
+  );
   stringIn(
     member.modifier,
     /* @__PURE__ */ new Set([
@@ -24340,12 +24981,14 @@ function assertInterfaceMember(value, path) {
       "name",
       "type",
       "settable",
+      "accessModifier",
       "source"
     ]);
     nonEmptyString(member.id, `${path}.id`);
     nonEmptyString(member.name, `${path}.name`);
     assertType2(member.type, `${path}.type`);
     booleanAt(member.settable, `${path}.settable`);
+    assertInterfaceMemberAccessModifier(member.accessModifier, path);
     assertSourceIdentity(member.source, `${path}.source`, "interfaceMember");
     return;
   }
@@ -24357,16 +25000,21 @@ function assertInterfaceMember(value, path) {
       "returnType",
       "arguments",
       "deferred",
+      "accessModifier",
       "source"
     ]);
     nonEmptyString(member.id, `${path}.id`);
     nonEmptyString(member.name, `${path}.name`);
     assertFunctionSignature(member, path);
+    assertInterfaceMemberAccessModifier(member.accessModifier, path);
     assertSourceIdentity(member.source, `${path}.source`, "interfaceMember");
     return;
   }
   invalid(`${path}.kind`, "must be property or function.");
 }
+function assertInterfaceMemberAccessModifier(value, path) {
+  stringIn(value, /* @__PURE__ */ new Set(["public", "protected"]), `${path}.accessModifier`);
+}
 function assertEnum2(value, path) {
   const neoEnum = objectAt(value, path, [
     "id",
@@ -25112,6 +25760,7 @@ var init_validate = __esm({
       "owner",
       "name",
       "isStatic",
+      "accessModifier",
       "modifier",
       "locked",
       "required",
@@ -26923,6 +27572,10 @@ function memberCommon(context, ownerClass, declaration, id2, owner, base) {
     owner,
     name: declaration.name,
     isStatic: declaration.modifiers.includes("static"),
+    // Non-class placements (collection entries, generic arguments, loose
+    // members) have no receiver type to scope visibility to; they are
+    // structurally public. Class schema entries apply the C# omission default.
+    accessModifier: owner.kind === "classMember" ? effectiveSourceAccessModifier(declaration.modifiers, "class") : "public",
     modifier: memberModifier2(declaration.modifiers, base?.modifier),
     locked: hasAnnotation(declaration.annotations, "locked"),
     required: declaration.kind === "field" ? !declaration.type.nullable : base?.required ?? false,
@@ -27140,6 +27793,10 @@ function lowerInterface(context, declaration) {
       `${declaration.name}.${member.name}`
     );
     const source = sourceIdentity2(member, "interfaceMember", member.name);
+    const accessModifier = effectiveSourceAccessModifier(
+      member.modifiers,
+      "interface"
+    );
     if (member.kind === "function") {
       return {
         id: memberId,
@@ -27153,6 +27810,7 @@ function lowerInterface(context, declaration) {
           selectionSpan: span(parameter3)
         })),
         deferred: member.modifiers.includes("async"),
+        accessModifier,
         source
       };
     }
@@ -27162,6 +27820,7 @@ function lowerInterface(context, declaration) {
       name: member.name,
       type: lowerType(context, member.type),
       settable: /\bset\s*;/.test(member.body ?? ""),
+      accessModifier,
       source
     };
   });
@@ -28660,11 +29319,12 @@ function emitInterface(context, value) {
     (interfaceId) => required(context.interfaces, interfaceId, "interface").name
   );
   const members = value.members.map((member) => {
+    const access = member.accessModifier === "public" ? "" : `${member.accessModifier} `;
     if (member.kind === "property") {
-      return `${id(member.id)}${renderType(context, member.type)} ${member.name} { get;${member.settable ? " set;" : ""} }`;
+      return `${id(member.id)}${access}${renderType(context, member.type)} ${member.name} { get;${member.settable ? " set;" : ""} }`;
     }
     const deferred = member.deferred ? "async " : "";
-    return `${id(member.id)}${deferred}${renderReturnType(context, member.returnType)} ${member.name}(${member.arguments.map(
+    return `${id(member.id)}${access}${deferred}${renderReturnType(context, member.returnType)} ${member.name}(${member.arguments.map(
       (argument2) => `${renderType(context, argument2.type)} ${argument2.name}`
     ).join(", ")});`;
   });
@@ -28729,9 +29389,10 @@ ${body ? `${signature} ${body}` : abstractContract ? `${signature};` : `native $
 ${prefix}${type} ${member.name}${initializer === null ? ";" : ` = ${initializer};`}`;
 }
 function memberModifier3(member) {
+  const accessPrefix = `${member.accessModifier} `;
   const staticPrefix = member.isStatic ? "static " : "";
   const modifier = member.modifier === "plain" ? "" : member.modifier === "abstractOverride" ? "abstract override " : member.modifier === "sealedOverride" ? "override " : `${member.modifier} `;
-  return `${staticPrefix}${modifier}`;
+  return `${accessPrefix}${staticPrefix}${modifier}`;
 }
 function renderExtendsGenericBindings(context, schemaClass2, base) {
   if (base.genericParameters.length === 0) return "";
@@ -32801,6 +33462,11 @@ var init_neoscript = __esm({
 });
 
 // ../src/models/members/member-kinds.ts
+function isMemberAccessModifierKind(value) {
+  if (value === "public") return true;
+  if (value === "protected") return true;
+  return value === "private";
+}
 function isValidCallableIdentifier(value) {
   if (typeof value !== "string") return false;
   if (!FunctionMemberNamePattern.test(value)) return false;
@@ -33244,6 +33910,7 @@ function isMemberBase(value) {
   if (typeof v.locked !== "boolean") return false;
   if (typeof v.required !== "boolean") return false;
   if (typeof v.isStatic !== "boolean") return false;
+  if (!isMemberAccessModifierKind(v.accessModifierKind)) return false;
   if (v.isVirtual !== void 0 && typeof v.isVirtual !== "boolean") {
     return false;
   }
@@ -33299,6 +33966,7 @@ function isMemberOverrideBase(value) {
   if (v.locked !== void 0 && typeof v.locked !== "boolean") return false;
   if (v.required !== void 0 && typeof v.required !== "boolean") return false;
   if (v.isStatic !== void 0 && v.isStatic !== false) return false;
+  if (!isMemberAccessModifierKind(v.accessModifierKind)) return false;
   if (v.isVirtual !== void 0 && typeof v.isVirtual !== "boolean") {
     return false;
   }
@@ -33806,6 +34474,9 @@ function substituteMember(member, env, members) {
       ...binding,
       name: resolved.name,
       locked: resolved.locked,
+      // Accessibility is a slot-owned declaration field — a binding member's
+      // modifier must not change the declaring slot's visibility.
+      accessModifierKind: resolved.accessModifierKind,
       system: resolved.system ?? void 0
     };
     const slotId = getOptionalString(member, "id");
@@ -35112,6 +35783,7 @@ function isNeoInterfaceMember(value) {
   if (value === null) return false;
   const member = value;
   if (typeof member.id !== "string" || member.id.length === 0) return false;
+  if (!isMemberAccessModifierKind(member.accessModifierKind)) return false;
   if (member.kind === "property") {
     if (!isNSTypeInfo(member.typeInfo)) return false;
     if (containsForbiddenMemberTypeInfo(member.typeInfo)) return false;
@@ -44476,6 +45148,29 @@ function migrateMemberStaticOwnership(data) {
   if (Object.prototype.hasOwnProperty.call(data, "isStatic")) return data;
   return { ...data, isStatic: false };
 }
+function migrateMemberAccessModifier(data) {
+  if (!isRecord5(data)) return data;
+  if (Object.prototype.hasOwnProperty.call(data, "accessModifierKind")) {
+    return data;
+  }
+  return { ...data, accessModifierKind: "public" };
+}
+function migrateInterfaceMemberAccessModifiers(data) {
+  if (!isRecord5(data)) return data;
+  const members = data.members;
+  if (!isRecord5(members)) return data;
+  let nextMembers = members;
+  for (const [memberKey, member] of Object.entries(members)) {
+    if (!isRecord5(member)) continue;
+    if (Object.prototype.hasOwnProperty.call(member, "accessModifierKind")) {
+      continue;
+    }
+    if (nextMembers === members) nextMembers = { ...members };
+    nextMembers[memberKey] = { ...member, accessModifierKind: "public" };
+  }
+  if (nextMembers === members) return data;
+  return { ...data, members: nextMembers };
+}
 function migrateProjectRecordData(args) {
   const currentVersion = CURRENT_PROJECT_RECORD_DATA_SCHEMA_VERSION[args.recordKind];
   if (args.dataSchemaVersion > currentVersion) {
@@ -44659,12 +45354,12 @@ var init_project_record_migrations = __esm({
     init_neoscript_call_receiver_migration();
     CURRENT_PROJECT_RECORD_DATA_SCHEMA_VERSION = {
       [ProjectRecordKind.Project]: 1,
-      [ProjectRecordKind.Member]: 4,
+      [ProjectRecordKind.Member]: 5,
       [ProjectRecordKind.Value]: 1,
       [ProjectRecordKind.Class]: 1,
       [ProjectRecordKind.InternalRecordRelation]: 1,
       [ProjectRecordKind.Enum]: 4,
-      [ProjectRecordKind.Interface]: 2,
+      [ProjectRecordKind.Interface]: 3,
       [ProjectRecordKind.Dialogue]: 5,
       [ProjectRecordKind.DialogueNode]: 4,
       [ProjectRecordKind.DialogueGroup]: 4,
@@ -44682,7 +45377,8 @@ var init_project_record_migrations = __esm({
       [ProjectRecordKind.Member]: {
         1: migrateGeneralFunctionCallIR,
         2: migrateMemberStaticOwnership,
-        3: migrateExplicitCallReceiverIR
+        3: migrateExplicitCallReceiverIR,
+        4: migrateMemberAccessModifier
       },
       [ProjectRecordKind.Value]: {},
       [ProjectRecordKind.Class]: {},
@@ -44690,7 +45386,9 @@ var init_project_record_migrations = __esm({
       [ProjectRecordKind.Enum]: {
         1: migrateEnumOptionKeyOrder
       },
-      [ProjectRecordKind.Interface]: {},
+      [ProjectRecordKind.Interface]: {
+        2: migrateInterfaceMemberAccessModifiers
+      },
       [ProjectRecordKind.Dialogue]: {
         1: migrateDialoguePrimaryLinkedValues,
         2: migrateGeneralFunctionCallIR,
@@ -53057,7 +53755,8 @@ function constructClassValue(info, scope, ctx) {
     classId,
     locked: false,
     required: true,
-    isStatic: false
+    isStatic: false,
+    accessModifierKind: "public"
   };
   const createdValues = [];
   const storageKeyDeclarations = /* @__PURE__ */ new Map();