diff --git a/SharpTS.TypeScriptConformance/baselines/interpreted.txt b/SharpTS.TypeScriptConformance/baselines/interpreted.txt
index a9f1658e..2522c0b4 100644
--- a/SharpTS.TypeScriptConformance/baselines/interpreted.txt
+++ b/SharpTS.TypeScriptConformance/baselines/interpreted.txt
@@ -95,10 +95,10 @@ tests/cases/conformance/es6/Symbols/symbolProperty18.ts Pass
 tests/cases/conformance/es6/Symbols/symbolProperty19.ts Pass
 tests/cases/conformance/es6/Symbols/symbolProperty2.ts Pass
 tests/cases/conformance/es6/Symbols/symbolProperty20.ts Pass
-tests/cases/conformance/es6/Symbols/symbolProperty21.ts Fail
+tests/cases/conformance/es6/Symbols/symbolProperty21.ts Pass
 tests/cases/conformance/es6/Symbols/symbolProperty22.ts Pass
 tests/cases/conformance/es6/Symbols/symbolProperty23.ts Pass
-tests/cases/conformance/es6/Symbols/symbolProperty24.ts Fail
+tests/cases/conformance/es6/Symbols/symbolProperty24.ts Pass
 tests/cases/conformance/es6/Symbols/symbolProperty25.ts Pass
 tests/cases/conformance/es6/Symbols/symbolProperty26.ts Pass
 tests/cases/conformance/es6/Symbols/symbolProperty27.ts Pass
@@ -132,7 +132,7 @@ tests/cases/conformance/es6/Symbols/symbolProperty51.ts Pass
 tests/cases/conformance/es6/Symbols/symbolProperty52.ts Pass
 tests/cases/conformance/es6/Symbols/symbolProperty53.ts Pass
 tests/cases/conformance/es6/Symbols/symbolProperty54.ts Pass
-tests/cases/conformance/es6/Symbols/symbolProperty55.ts Fail
+tests/cases/conformance/es6/Symbols/symbolProperty55.ts Pass
 tests/cases/conformance/es6/Symbols/symbolProperty56.ts Pass
 tests/cases/conformance/es6/Symbols/symbolProperty57.ts Pass
 tests/cases/conformance/es6/Symbols/symbolProperty58.ts Pass
@@ -149,7 +149,7 @@ tests/cases/conformance/es6/Symbols/symbolType11.ts Pass
 tests/cases/conformance/es6/Symbols/symbolType12.ts Pass
 tests/cases/conformance/es6/Symbols/symbolType13.ts Pass
 tests/cases/conformance/es6/Symbols/symbolType14.ts Pass
-tests/cases/conformance/es6/Symbols/symbolType15.ts Fail
+tests/cases/conformance/es6/Symbols/symbolType15.ts Pass
 tests/cases/conformance/es6/Symbols/symbolType16.ts Pass
 tests/cases/conformance/es6/Symbols/symbolType17.ts Pass
 tests/cases/conformance/es6/Symbols/symbolType18.ts Pass
@@ -162,7 +162,7 @@ tests/cases/conformance/es6/Symbols/symbolType5.ts Pass
 tests/cases/conformance/es6/Symbols/symbolType6.ts Pass
 tests/cases/conformance/es6/Symbols/symbolType7.ts Pass
 tests/cases/conformance/es6/Symbols/symbolType8.ts Pass
-tests/cases/conformance/es6/Symbols/symbolType9.ts Fail
+tests/cases/conformance/es6/Symbols/symbolType9.ts Pass
 tests/cases/conformance/esnext/logicalAssignment/logicalAssignment11.ts Pass
 tests/cases/conformance/types/conditional/conditionalTypes1.ts Pass
 tests/cases/conformance/types/conditional/conditionalTypes2.ts Pass
@@ -245,7 +245,7 @@ tests/cases/conformance/types/typeRelationships/assignmentCompatibility/undefine
 tests/cases/conformance/types/typeRelationships/assignmentCompatibility/unionTypesAssignability.ts Pass
 tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/enumIsNotASubtypeOfAnythingButNumber.ts Pass
 tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/nullIsSubtypeOfEverythingButUndefined.ts Pass
-tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/stringLiteralTypeIsSubtypeOfString.ts Fail
+tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/stringLiteralTypeIsSubtypeOfString.ts Pass
 tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfAny.ts Pass
 tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameter.ts Pass
 tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameterWithConstraints.ts Pass
diff --git a/SharpTS.csproj b/SharpTS.csproj
index 4f53df48..e708acf1 100644
--- a/SharpTS.csproj
+++ b/SharpTS.csproj
@@ -44,6 +44,12 @@
     <None Remove="stdlib\**\*.ts" />
   </ItemGroup>
 
+  <!-- Ambient lib type declarations parsed by LibTypeLoader into the type checker (#99). -->
+  <ItemGroup>
+    <EmbeddedResource Include="libdefs\**\*.d.ts" />
+    <None Remove="libdefs\**\*.d.ts" />
+  </ItemGroup>
+
   <!-- Exclude test, example, benchmark, and SDK projects from this compilation.
        This list is hand-maintained and load-bearing: because this project sits at
        the repo root, the SDK's default **/*.cs glob would otherwise pull in every
diff --git a/TypeSystem/LibTypeLoader.cs b/TypeSystem/LibTypeLoader.cs
new file mode 100644
index 00000000..49173281
--- /dev/null
+++ b/TypeSystem/LibTypeLoader.cs
@@ -0,0 +1,49 @@
+using System.Collections.Frozen;
+using SharpTS.Parsing;
+
+namespace SharpTS.TypeSystem;
+
+/// <summary>
+/// #99 increment 2 — the lib.d.ts loader. Parses the ambient TypeScript lib declarations embedded as
+/// <c>libdefs/*.d.ts</c> resources and resolves them to modeled <see cref="TypeInfo"/>, so the type
+/// checker resolves lib names (e.g. <c>SymbolConstructor</c>) from real declarations instead of
+/// hand-modeled shapes. Built once and cached process-wide (the lib types are the same for every
+/// checker instance). A later increment expands the embedded sources toward the full vendored
+/// <c>external/typescript/src/lib/*.d.ts</c>.
+/// </summary>
+internal static class LibTypeLoader
+{
+    private static FrozenDictionary<string, TypeInfo>? _types;
+
+    /// <summary>Ambient lib type name → its resolved <see cref="TypeInfo"/>.</summary>
+    public static FrozenDictionary<string, TypeInfo> Types => _types ??= Build();
+
+    public static bool TryGet(string name, out TypeInfo type)
+    {
+        if (Types.TryGetValue(name, out var t)) { type = t; return true; }
+        type = null!;
+        return false;
+    }
+
+    private static FrozenDictionary<string, TypeInfo> Build()
+    {
+        var statements = new List<Stmt>();
+        var assembly = typeof(LibTypeLoader).Assembly;
+        foreach (var resourceName in assembly.GetManifestResourceNames())
+        {
+            if (!resourceName.Contains("libdefs") || !resourceName.EndsWith(".d.ts"))
+                continue;
+            using var stream = assembly.GetManifestResourceStream(resourceName);
+            if (stream is null) continue;
+            using var reader = new StreamReader(stream);
+            var parseResult = new Parser(new Lexer(reader.ReadToEnd()).ScanTokens()).Parse();
+            if (parseResult.IsSuccess)
+                statements.AddRange(parseResult.Statements);
+        }
+        // Resolve to TypeInfo via a throwaway checker; its diagnostics are discarded (lib sources are
+        // trusted). Empty-dict on any failure so a broken embed degrades to the prior hand-modeling.
+        return statements.Count > 0
+            ? new TypeChecker().ExtractLibTypes(statements)
+            : FrozenDictionary<string, TypeInfo>.Empty;
+    }
+}
diff --git a/TypeSystem/TypeChecker.Calls.cs b/TypeSystem/TypeChecker.Calls.cs
index 730ddc27..1cc068f7 100644
--- a/TypeSystem/TypeChecker.Calls.cs
+++ b/TypeSystem/TypeChecker.Calls.cs
@@ -97,6 +97,13 @@ private TypeInfo CheckCall(Expr.Call call)
             var instantiatedFunc = InstantiateGenericFunction(genericFunc, typeArgs);
             if (instantiatedFunc is TypeInfo.Function instFunc)
             {
+                // Excess-property check for fresh object-literal args against the instantiated
+                // parameter types (the generic path otherwise skips argument validation).
+                for (int ai = 0; ai < call.Arguments.Count && ai < instFunc.ParamTypes.Count; ai++)
+                {
+                    if (call.Arguments[ai] is Expr.ObjectLiteral && argTypes[ai] is TypeInfo.Record argRec)
+                        CheckExcessProperties(argRec, instFunc.ParamTypes[ai], call.Arguments[ai]);
+                }
                 return instFunc.ReturnType;
             }
             return new TypeInfo.Any();
@@ -211,6 +218,13 @@ private TypeInfo CheckCall(Expr.Call call)
                         {
                             argType = CheckExpr(arg);
                         }
+                        // Excess-property check for a FRESH object-literal argument (tsc's fresh-literal
+                        // rule) against its parameter type — mirrors the assignment path.
+                        if (arg is Expr.ObjectLiteral && argType is TypeInfo.Record argExcessRecord
+                            && paramIndex < regularParamCount)
+                        {
+                            CheckExcessProperties(argExcessRecord, funcType.ParamTypes[paramIndex], arg);
+                        }
                         if (paramIndex < regularParamCount)
                         {
                             // Check against regular parameter. An optional/default-valued parameter
diff --git a/TypeSystem/TypeChecker.Compatibility.Structural.cs b/TypeSystem/TypeChecker.Compatibility.Structural.cs
index 10e16c82..71acf899 100644
--- a/TypeSystem/TypeChecker.Compatibility.Structural.cs
+++ b/TypeSystem/TypeChecker.Compatibility.Structural.cs
@@ -100,6 +100,15 @@ private void CheckExcessProperties(TypeInfo.Record actual, TypeInfo expected, Ex
             hasStringIndex = cls.StringIndexType != null;
             hasNumberIndex = cls.NumberIndexType != null;
         }
+        else if (expected is TypeInfo.InstantiatedGeneric ig && FlattenInstantiatedInterface(ig) is { } flatIface)
+        {
+            // A generic interface argument (`I<number>`) flattens to its concrete members so a fresh
+            // object literal passed to a generic function is excess-checked too.
+            foreach (var member in flatIface.GetAllMembers())
+                expectedKeys.Add(member.Key);
+            hasStringIndex = flatIface.StringIndexType != null;
+            hasNumberIndex = flatIface.NumberIndexType != null;
+        }
         else
         {
             // For other types (primitives, unions, etc.), skip excess property check
@@ -136,11 +145,32 @@ private void CheckExcessProperties(TypeInfo.Record actual, TypeInfo expected, Ex
             throw new TypeCheckException(
                 $"Object literal may only specify known properties. " +
                 $"Excess {(excessKeys.Count == 1 ? "property" : "properties")}: {excessList}",
+                line: ExcessPropertyLine(sourceExpr, excessKeys[0]),
                 tsCode: "TS2353"
             );
         }
     }
 
+    /// <summary>The source line of an excess property (for TS2353 attribution) — the offending
+    /// property's own line rather than the enclosing statement's, which matters when the object
+    /// literal spans multiple lines (e.g. a multi-line call argument). Null if it can't be located.</summary>
+    private static int? ExcessPropertyLine(Expr sourceExpr, string excessKey)
+    {
+        if (sourceExpr is not Expr.ObjectLiteral obj) return null;
+        foreach (var prop in obj.Properties)
+        {
+            if (prop.Key is { } key && GetAccessorMemberName(key) == excessKey)
+                return key switch
+                {
+                    Expr.IdentifierKey id => id.Name.Line,
+                    Expr.LiteralKey lit => lit.Literal.Line,
+                    Expr.ComputedKey ck => TryGetExprLine(ck.Expression),
+                    _ => null
+                };
+        }
+        return null;
+    }
+
     private TypeInfo? GetMemberType(TypeInfo type, string name)
     {
         if (type is TypeInfo.Record record)
diff --git a/TypeSystem/TypeChecker.Operators.cs b/TypeSystem/TypeChecker.Operators.cs
index a853fca1..14ce05c8 100644
--- a/TypeSystem/TypeChecker.Operators.cs
+++ b/TypeSystem/TypeChecker.Operators.cs
@@ -26,7 +26,7 @@ private TypeInfo CheckBinary(Expr.Binary binary)
             OperatorDescriptor.Plus => CheckPlusOperator(left, right, line),
             OperatorDescriptor.Arithmetic or OperatorDescriptor.Power => CheckArithmeticBinary(left, right, line),
             OperatorDescriptor.Comparison => CheckComparisonBinary(left, right, binary.Operator.Lexeme, line),
-            OperatorDescriptor.Equality => new TypeInfo.Primitive(TokenType.TYPE_BOOLEAN),
+            OperatorDescriptor.Equality => CheckEqualityBinary(left, right, line),
             OperatorDescriptor.Bitwise or OperatorDescriptor.BitwiseShift => CheckBitwiseBinary(left, right, line),
             OperatorDescriptor.UnsignedRightShift => CheckUnsignedShiftBinary(left, right, line),
             OperatorDescriptor.In => CheckInOperator(right, line),
@@ -51,6 +51,31 @@ private TypeInfo CheckInOperator(TypeInfo right, int line)
         return new TypeInfo.Primitive(TokenType.TYPE_BOOLEAN);
     }
 
+    /// <summary>
+    /// Equality (<c>==</c>/<c>!=</c>/<c>===</c>/<c>!==</c>). tsc's "no overlap" check (TS2367) is broad,
+    /// but only the symbol-vs-non-symbol-primitive slice is implemented here (scoped to keep other
+    /// comparisons untouched): a <c>symbol</c> can never equal a <c>boolean</c>/<c>number</c>/
+    /// <c>string</c>/<c>bigint</c>, so comparing them is flagged unintentional. A symbol vs symbol / vs
+    /// <c>any</c> / vs a union that could hold a symbol is fine.
+    /// </summary>
+    private TypeInfo CheckEqualityBinary(TypeInfo left, TypeInfo right, int line)
+    {
+        bool leftSym = left is TypeInfo.Symbol or TypeInfo.UniqueSymbol;
+        bool rightSym = right is TypeInfo.Symbol or TypeInfo.UniqueSymbol;
+        if (leftSym != rightSym)
+        {
+            TypeInfo other = leftSym ? right : left;
+            if (other is TypeInfo.Primitive or TypeInfo.String or TypeInfo.NumberLiteral
+                or TypeInfo.StringLiteral or TypeInfo.BooleanLiteral or TypeInfo.BigInt or TypeInfo.BigIntLiteral)
+            {
+                throw new TypeCheckException(
+                    $"This comparison appears to be unintentional because the types '{left}' and '{right}' have no overlap.",
+                    line > 0 ? line : null, tsCode: "TS2367");
+            }
+        }
+        return new TypeInfo.Primitive(TokenType.TYPE_BOOLEAN);
+    }
+
     /// <summary>
     /// True if this type is Any, Inferred, or a Union containing an Any/Inferred arm.
     /// A union that includes 'any' is effectively permissive (JS semantics); operators
diff --git a/TypeSystem/TypeChecker.Statements.Classes.cs b/TypeSystem/TypeChecker.Statements.Classes.cs
index b13590aa..cba49011 100644
--- a/TypeSystem/TypeChecker.Statements.Classes.cs
+++ b/TypeSystem/TypeChecker.Statements.Classes.cs
@@ -547,6 +547,9 @@ TypeInfo.Function BuildMethodFuncType(Stmt.Function method)
         }
 
         // Validate implemented interfaces (skip for generic classes - validated at instantiation)
+        // Resolved interfaces are captured so an un-annotated method's INFERRED return type can be
+        // re-checked against them after the body pass (this validation runs before inference).
+        List<TypeInfo.Interface> implementsForRecheck = [];
         if (classStmt.Interfaces != null && classTypeParams == null)
         {
             for (int i = 0; i < classStmt.Interfaces.Count; i++)
@@ -554,6 +557,13 @@ TypeInfo.Function BuildMethodFuncType(Stmt.Function method)
                 var interfaceToken = classStmt.Interfaces[i];
                 TypeInfo? itfTypeInfo = _environment.Get(interfaceToken.Lexeme);
 
+                // #99: a lib wrapper type (`implements String`) resolves to the primitive in type
+                // position, not an interface — consult the loaded lib for a real interface so it's a
+                // valid implements target rather than a spurious "not an interface" (TS2304).
+                if (itfTypeInfo is not TypeInfo.Interface and not TypeInfo.GenericInterface
+                    && LibTypeLoader.TryGet(interfaceToken.Lexeme, out var libImplements))
+                    itfTypeInfo = libImplements;
+
                 // Get type arguments for this interface if provided
                 List<string>? typeArgs = classStmt.InterfaceTypeArgs != null && i < classStmt.InterfaceTypeArgs.Count
                     ? classStmt.InterfaceTypeArgs[i]
@@ -613,6 +623,7 @@ TypeInfo.Function BuildMethodFuncType(Stmt.Function method)
                 }
 
                 ValidateInterfaceImplementation(classTypeForBody, interfaceType, classStmt.Name.Lexeme, classStmt.Name.Line);
+                implementsForRecheck.Add(interfaceType);
             }
         }
 
@@ -1106,7 +1117,12 @@ TypeInfo.Function BuildMethodFuncType(Stmt.Function method)
         // `[Symbol.x]()` method carries its inferred return type rather than the <inferred> placeholder
         // it held at the string-index check earlier (ValidateClassPropertiesAgainstIndex).
         mutableClass.ResetFrozenCache();
-        ValidateClassMembersAgainstSymbolIndex(classStmt, mutableClass.Freeze());
+        var finalizedClass = mutableClass.Freeze();
+        ValidateClassMembersAgainstSymbolIndex(classStmt, finalizedClass);
+        // Re-check implemented-interface method compatibility now that un-annotated method return
+        // types are inferred (the pre-inference pass above saw a <inferred> placeholder — TS2416).
+        if (implementsForRecheck.Count > 0)
+            RecheckImplementsInferredReturns(classStmt, finalizedClass, implementsForRecheck);
     }
 
     /// <summary>
diff --git a/TypeSystem/TypeChecker.Statements.Interfaces.cs b/TypeSystem/TypeChecker.Statements.Interfaces.cs
index ad555789..b2c8877e 100644
--- a/TypeSystem/TypeChecker.Statements.Interfaces.cs
+++ b/TypeSystem/TypeChecker.Statements.Interfaces.cs
@@ -396,6 +396,10 @@ private void CheckInterfaceDeclaration(Stmt.Interface interfaceStmt)
                 var extendType = ResolveAnnotation(
                     extendTypeName,
                     interfaceStmt.ExtendsNodes != null && i < interfaceStmt.ExtendsNodes.Count ? interfaceStmt.ExtendsNodes[i] : null)!;
+                // #99: `interface I extends String` — the wrapper name resolves to the primitive; use
+                // the loaded lib interface so it's a valid extends target (not a spurious TS2312).
+                if (extendType is not TypeInfo.Interface && LibTypeLoader.TryGet(extendTypeName, out var libExtends))
+                    extendType = libExtends;
                 if (extendType is TypeInfo.Interface extendInterface)
                 {
                     extendsList.Add(extendInterface);
diff --git a/TypeSystem/TypeChecker.Statements.cs b/TypeSystem/TypeChecker.Statements.cs
index 584a9e9f..dbcbcb62 100644
--- a/TypeSystem/TypeChecker.Statements.cs
+++ b/TypeSystem/TypeChecker.Statements.cs
@@ -297,6 +297,8 @@ private void ReportUnknownTypeName(string? annotation, TypeNode? annotationNode,
         if (_environment.GetTypeAlias(name) is not null) return;
         if (_environment.GetGenericTypeAlias(name) is not null) return;
         if (_openTypeVariablesInScope?.Contains(name) == true) return;
+        // #99 lib-type seam: an ambient lib.d.ts type name (e.g. Symbol/SymbolConstructor) is known.
+        if (TryResolveLibType(name) is not null) return;
 
         throw new TypeCheckException($" Cannot find name '{name}'.", line, tsCode: "TS2304");
     }
diff --git a/TypeSystem/TypeChecker.TypeParsing.cs b/TypeSystem/TypeChecker.TypeParsing.cs
index 09b176b5..59365f09 100644
--- a/TypeSystem/TypeChecker.TypeParsing.cs
+++ b/TypeSystem/TypeChecker.TypeParsing.cs
@@ -232,9 +232,37 @@ private TypeInfo ResolveTypeNameCore(string typeName)
             return enumType;
         }
 
+        // #99 lib-type seam: ambient lib.d.ts TYPE-position names SharpTS doesn't load from the
+        // .d.ts files yet (checked AFTER user declarations above, so a user interface of the same
+        // name wins). A later increment backs this with a real lib.d.ts loader.
+        if (TryResolveLibType(typeName) is { } libType)
+        {
+            return libType;
+        }
+
         return new TypeInfo.Any();
     }
 
+    /// <summary>
+    /// The #99 lib-type seam: resolves the ambient TYPE-position names that lib.d.ts declares but
+    /// SharpTS doesn't yet parse from the vendored .d.ts files, to their modeled <see cref="TypeInfo"/>.
+    /// Consulted by both <see cref="ResolveTypeNameCore"/> (for the type) and
+    /// <c>ReportUnknownTypeName</c> (so these names aren't flagged TS2304). Increment 1 covers the
+    /// Symbol family; a later increment replaces this switch with content loaded from lib.d.ts.
+    /// </summary>
+    private static TypeInfo? TryResolveLibType(string name)
+    {
+        // Names loaded from the embedded lib.d.ts (e.g. SymbolConstructor) — the real declarations.
+        if (LibTypeLoader.TryGet(name, out var libType)) return libType;
+        // Names still hand-modeled (the wrapper types need behavior the loaded shape can't yet give —
+        // a symbol must satisfy `Symbol` without SharpTS modeling the primitive's apparent members).
+        return name switch
+        {
+            "Symbol" => WellKnownSymbolTypes.SymbolWrapper,
+            _ => null
+        };
+    }
+
     /// <summary>
     /// Simplifies an intersection type according to TypeScript semantics:
     /// - Conflicting primitives (string &amp; number) = never
diff --git a/TypeSystem/TypeChecker.Validation.cs b/TypeSystem/TypeChecker.Validation.cs
index 26288096..ca34c00b 100644
--- a/TypeSystem/TypeChecker.Validation.cs
+++ b/TypeSystem/TypeChecker.Validation.cs
@@ -103,6 +103,38 @@ private void ValidateInterfaceImplementation(TypeInfo.Class classType, TypeInfo.
         }
     }
 
+    /// <summary>
+    /// Re-checks that an un-annotated method implementing an interface member has a compatible
+    /// INFERRED return type (TS2416), reported at the method's own line. The normal implements
+    /// validation runs before the body pass, when an un-annotated return is still a <c>&lt;inferred&gt;</c>
+    /// placeholder (≈ any) that hides the mismatch; this runs after inference. Only un-annotated
+    /// implementations are considered, so annotated methods (already checked) aren't double-reported.
+    /// </summary>
+    private void RecheckImplementsInferredReturns(Stmt.Class classStmt, TypeInfo.Class classType, List<TypeInfo.Interface> interfaces)
+    {
+        foreach (var method in classStmt.Methods)
+        {
+            if (method.ReturnType != null || method.Body == null) continue;
+            string name = method.ComputedKey != null
+                ? (TryGetWellKnownSymbolMemberName(method.ComputedKey) ?? method.Name.Lexeme)
+                : method.Name.Lexeme;
+            if (FindMemberInClass(classType, name) is not TypeInfo.Function actualFunc) continue;
+            int line = method.ComputedKey != null ? (TryGetExprLine(method.ComputedKey) ?? method.Name.Line) : method.Name.Line;
+            foreach (var itf in interfaces)
+            {
+                if (itf.GetAllMembers().FirstOrDefault(m => m.Key == name).Value is TypeInfo.Function expectedFunc
+                    && !IsCompatible(expectedFunc.ReturnType, actualFunc.ReturnType))
+                {
+                    string display = name.StartsWith("@@") ? $"[Symbol.{name[2..]}]" : name;
+                    RecordTypeError(new TypeCheckException(
+                        $" Property '{display}' in type '{classStmt.Name.Lexeme}' is not assignable to the same property in base type '{itf.Name}'.",
+                        line: line, tsCode: "TS2416"));
+                    break;
+                }
+            }
+        }
+    }
+
     /// <summary>
     /// The built-in iterable-protocol interfaces a class may legally list in its <c>implements</c>
     /// clause. These are NOT user-declared <c>interface</c>s (so they are absent from the type
diff --git a/TypeSystem/TypeChecker.cs b/TypeSystem/TypeChecker.cs
index 723d880e..f699c63d 100644
--- a/TypeSystem/TypeChecker.cs
+++ b/TypeSystem/TypeChecker.cs
@@ -1035,6 +1035,30 @@ private bool IsLenientModule()
     /// Full validation happens later during CheckStmt.
     /// Note: Classes are NOT pre-registered to avoid breaking inheritance checking with MutableClass.
     /// </summary>
+    /// <summary>
+    /// #99: register a set of ambient lib declarations into this (throwaway) checker's environment and
+    /// return the resolved interfaces/type-aliases keyed by name. Diagnostics are suppressed — lib
+    /// sources are trusted. Used by <see cref="LibTypeLoader"/> to turn parsed <c>libdefs/*.d.ts</c>
+    /// into modeled <see cref="TypeInfo"/>. Interfaces reference each other through the environment
+    /// (pre-registered above), so no recursion back into the loader.
+    /// </summary>
+    internal System.Collections.Frozen.FrozenDictionary<string, TypeInfo> ExtractLibTypes(List<Stmt> statements)
+    {
+        _suppressDiagnostics++;
+        try
+        {
+            PreRegisterTypeDeclarations(statements);
+            var result = new Dictionary<string, TypeInfo>();
+            foreach (var stmt in statements)
+            {
+                if (stmt is Stmt.Interface itf && _environment.Get(itf.Name.Lexeme) is { } t)
+                    result[itf.Name.Lexeme] = t;
+            }
+            return result.ToFrozenDictionary();
+        }
+        finally { _suppressDiagnostics--; }
+    }
+
     private void PreRegisterTypeDeclarations(IEnumerable<Stmt> statements)
     {
         foreach (var stmt in statements)
diff --git a/TypeSystem/WellKnownSymbolTypes.cs b/TypeSystem/WellKnownSymbolTypes.cs
index ef7333fd..7a700d60 100644
--- a/TypeSystem/WellKnownSymbolTypes.cs
+++ b/TypeSystem/WellKnownSymbolTypes.cs
@@ -74,6 +74,19 @@ public static class WellKnownSymbolTypes
     /// CheckGet) before generic member lookup ever consults this type, so adding it here doesn't
     /// change those paths — only genuine "use Symbol as a plain value" sites.
     /// </summary>
+    /// <summary>
+    /// The global `Symbol` WRAPPER object type (lib's `interface Symbol`), as it appears in TYPE
+    /// position (`var s: Symbol`). Distinct from the `symbol` primitive: a `symbol` value IS
+    /// assignable to this wrapper (an object-like target — the wrapper is modeled member-less so a
+    /// symbol satisfies it without SharpTS having to model symbol's apparent toString/valueOf), but
+    /// the wrapper is NOT assignable back to the `symbol` primitive (TS2322 "'symbol' is a primitive,
+    /// but 'Symbol' is a wrapper object").
+    /// </summary>
+    public static readonly TypeInfo.Interface SymbolWrapper = new(
+        "Symbol",
+        FrozenDictionary<string, TypeInfo>.Empty,
+        FrozenSet<string>.Empty);
+
     public static readonly TypeInfo.Interface SymbolConstructor = new(
         "SymbolConstructor",
         new Dictionary<string, TypeInfo>
diff --git a/libdefs/lib.core.d.ts b/libdefs/lib.core.d.ts
new file mode 100644
index 00000000..55588e46
--- /dev/null
+++ b/libdefs/lib.core.d.ts
@@ -0,0 +1,31 @@
+// Ambient lib type declarations loaded by LibTypeLoader (#99 increment 2). Embedded as a resource
+// so it is available at runtime — the full vendored TypeScript lib.d.ts is a dev-only submodule.
+// A faithful (member types simplified to `symbol` for now) subset, expanded toward the real
+// external/typescript/src/lib/*.d.ts in later #99 increments.
+
+// The primitive WRAPPER object types, as they appear in `implements`/`extends` position
+// (`class C implements String`, `interface I extends String`). Modeled member-less for now — enough
+// to be a valid implements/extends target (a class/interface trivially satisfies an empty base);
+// a later increment fills their real methods once the string/number/boolean primitives model their
+// apparent members so the primitive can satisfy the wrapper.
+interface String { }
+interface Number { }
+interface Boolean { }
+
+interface SymbolConstructor {
+    readonly iterator: symbol;
+    readonly asyncIterator: symbol;
+    readonly hasInstance: symbol;
+    readonly isConcatSpreadable: symbol;
+    readonly match: symbol;
+    readonly matchAll: symbol;
+    readonly replace: symbol;
+    readonly search: symbol;
+    readonly species: symbol;
+    readonly split: symbol;
+    readonly toPrimitive: symbol;
+    readonly toStringTag: symbol;
+    readonly unscopables: symbol;
+    for(key: string): symbol;
+    keyFor(sym: symbol): string | undefined;
+}