diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 5a5b2f1c1f..5d313502da 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -89,6 +89,71 @@ Each one of these scripts can be executed either from the root of the repo using
 `npx lerna run <script> --scope <package>` or from individual modules using
 `yarn <script>`.
 
+#### Reproducting Bugs (Test-Driven Solving)
+
+Troubleshooting bugs usually starts with adding a new test that demonstrates the
+faulty behavior, then modifying implementations until the test passes.
+
+The `jsii-calc` and `@scope/*` packages are used to test expected brhavior from
+the compiler (note that the [aws/jsii-compiler](github.com/aws/jsii-compiler)
+repository as a separate copy of these under the `fixtures` directory), as well
+as downstream tooling (`jsii-pacmak`, `jsii-rosetta`, etc...). Each language
+runtime has its own test suite, within which is a _compliance_ suite that tests
+the same behaviors in all languages, and which should contain tests related to
+behavior that isn't strictly specific to the given language.
+
+The `yarn test:update` script in each package runs all tests and updates
+snapshots when necessary. It is usually necessary to run this script at least in
+`jsii-pacmak` and `jsii-reflect` after changing code in the `jsii-calc` or
+`@scope/*` packages.
+
+#### Debugging runtime behavior
+
+Cross-language runtime behavior can be challenging to debug, as data is passed
+across process boundaries through Inter-Process Communication (IPC) channels.
+Further complicating things, the `@jsii/runtime` library packaged in the various
+language runtimes is bundled (by `webpack`), which can make the Javascript
+runtime code more complicated to follow.
+
+Setting various environment variables can help understanding what is happening
+better:
+
+- `JSII_DEBUG=1` turns on verbose debug logging, which will cause the program to
+  emit extensive IPC tracing information to `STDERR`. This information can help
+  identify where things start to behave in unexpected ways, but can be a little
+  difficult to digest... One may want to refer to the [kernel API][kernel-api]
+  documentation to make sense of those traces.
+
+- `JSII_DEBUG_TIMING=1` turns on specific timing information from the
+  `@jsii/kernel` high level API processing, which can be useful to narrow down
+  the possible causes for performance issues.
+
+- `JSII_RUNTIME` can be set to point to the `bin/jsii-runtime` script within the
+  `@jsii/runtime` package in order to use a local, non-`webpack`ed version of
+  the runtime program. This can be particularly helpful when trying to diagnose
+  a problem within a debugger session.
+
+- `NODE_OPTIONS` can be used to configure specific behaviors of the underlying
+  `node` runtime, such as specifying `--inspect-brk` to cause the node process
+  to wait for a debugger to attach before proceeding. This is useful to attach
+  Node dev tools to the runtime as it starts in order to use its debugger.
+
+The [Visual Studio Code](https://code.visualstudio.com) _JavaScript Debug
+Terminal_ feature can be particularly useful paired with appropriate
+`JSII_RUNTIME` setting to run arbitrary jsii programs, automatically attaching
+the VSCode debugger at startup. These terminals inject a specially crafted
+`NODE_OPTIONS` variable that allows the VSCode debugger to consistently attach
+to all `node` processes spawned within its context, including child processes
+(which can be problematic when running with `--inspect-brk`, as the default
+debugger interface's port can only be used by one process at a time).
+
+Finally, the `debugger` Javascript statement can be added anywhere in the
+runtime code or tested libraries in order to cause debuggers (if attached) to
+pause. This can be easier (and more reliable) to set up than traditional
+conditional break points.
+
+[kernel-api]: https://aws.github.io/jsii/specification/3-kernel-api/
+
 #### Linting & Formatting
 
 Eslint and Prettier are used to lint and format our typescript code. The `lint`
diff --git a/packages/@jsii/kernel/src/kernel.ts b/packages/@jsii/kernel/src/kernel.ts
index 201304e50c..7acf8a37c1 100644
--- a/packages/@jsii/kernel/src/kernel.ts
+++ b/packages/@jsii/kernel/src/kernel.ts
@@ -43,6 +43,10 @@ export class Kernel {
    * Set to true for timing data to be emitted.
    */
   public debugTimingEnabled = false;
+  /**
+   * Set to true to validate assemblies upon loading (slow).
+   */
+  public validateAssemblies = false;
 
   readonly #assemblies = new Map<string, Assembly>();
   readonly #objects = new ObjectTable(this.#typeInfoForFqn.bind(this));
@@ -69,6 +73,7 @@ export class Kernel {
     this.#serializerHost = {
       objects: this.#objects,
       debug: this.#debug.bind(this),
+      isVisibleType: this.#isVisibleType.bind(this),
       findSymbol: this.#findSymbol.bind(this),
       lookupType: this.#typeInfoForFqn.bind(this),
     };
@@ -147,10 +152,10 @@ export class Kernel {
     }
 
     // read .jsii metadata from the root of the package
-    let assmSpec;
+    let assmSpec: spec.Assembly;
     try {
       assmSpec = this.#debugTime(
-        () => spec.loadAssemblyFromPath(packageDir),
+        () => spec.loadAssemblyFromPath(packageDir, this.validateAssemblies),
         `loadAssemblyFromPath(${packageDir})`,
       );
     } catch (e: any) {
@@ -159,10 +164,15 @@ export class Kernel {
       );
     }
 
+    // We do a `require.resolve` call, as otherwise, requiring with a directory will cause any `exports` from
+    // `package.json` to be ignored, preventing injection of a "lazy index" entry point.
+    const entryPoint = this.#require!.resolve(assmSpec.name, {
+      paths: [this.#installDir!],
+    });
     // load the module and capture its closure
     const closure = this.#debugTime(
-      () => this.#require!(packageDir),
-      `require(${packageDir})`,
+      () => this.#require!(entryPoint),
+      `require(${entryPoint})`,
     );
     const assm = new Assembly(assmSpec, closure);
     this.#debugTime(
@@ -333,7 +343,7 @@ export class Kernel {
       throw new JsiiFault(`${method} is an async method, use "begin" instead`);
     }
 
-    const fqn = jsiiTypeFqn(obj);
+    const fqn = jsiiTypeFqn(obj, this.#isVisibleType.bind(this));
     const ret = this.#ensureSync(
       `method '${objref[TOKEN_REF]}.${method}'`,
       () => {
@@ -420,7 +430,7 @@ export class Kernel {
       throw new JsiiFault(`Method ${method} is expected to be an async method`);
     }
 
-    const fqn = jsiiTypeFqn(obj);
+    const fqn = jsiiTypeFqn(obj, this.#isVisibleType.bind(this));
 
     const promise = fn.apply(
       obj,
@@ -568,6 +578,21 @@ export class Kernel {
   #addAssembly(assm: Assembly) {
     this.#assemblies.set(assm.metadata.name, assm);
 
+    // We can use jsii runtime type information from jsii 1.19.0 onwards... Note that a version of
+    // 0.0.0 means we are assessing against a development tree, which is newer...
+    const jsiiVersion = assm.metadata.jsiiVersion.split(' ', 1)[0];
+    const [jsiiMajor, jsiiMinor, _jsiiPatch, ..._rest] = jsiiVersion
+      .split('.')
+      .map((str) => parseInt(str, 10));
+    if (
+      jsiiVersion === '0.0.0' ||
+      jsiiMajor > 1 ||
+      (jsiiMajor === 1 && jsiiMinor >= 19)
+    ) {
+      this.#debug('Using compiler-woven runtime type information!');
+      return;
+    }
+
     // add the __jsii__.fqn property on every constructor. this allows
     // traversing between the javascript and jsii worlds given any object.
     for (const fqn of Object.keys(assm.metadata.types ?? {})) {
@@ -869,7 +894,7 @@ export class Kernel {
     methodInfo: spec.Method,
   ) {
     const methodName = override.method;
-    const fqn = jsiiTypeFqn(obj);
+    const fqn = jsiiTypeFqn(obj, this.#isVisibleType.bind(this));
     const methodContext = `${methodInfo.async ? 'async ' : ''}method${
       fqn ? `${fqn}#` : methodName
     }`;
@@ -1029,7 +1054,7 @@ export class Kernel {
     return curr;
   }
 
-  #typeInfoForFqn(fqn: string): spec.Type {
+  #typeInfoForFqn(fqn: spec.FQN): spec.Type {
     const components = fqn.split('.');
     const moduleName = components[0];
 
@@ -1047,6 +1072,26 @@ export class Kernel {
     return fqnInfo;
   }
 
+  /**
+   * Determines whether the provided FQN corresponds to a valid, exported type
+   * from any currently loaded assembly.
+   *
+   * @param fqn the tested FQN.
+   *
+   * @returns `true` IIF the FQN corresponds to a know exported type.
+   */
+  #isVisibleType(fqn: spec.FQN): boolean {
+    try {
+      /* ignored */ this.#typeInfoForFqn(fqn);
+      return true;
+    } catch (e) {
+      if (e instanceof JsiiFault) {
+        return false;
+      }
+      throw e;
+    }
+  }
+
   #typeInfoForMethod(
     methodName: string,
     fqn: string,
diff --git a/packages/@jsii/kernel/src/link.ts b/packages/@jsii/kernel/src/link.ts
index 51f95aa4f1..8d518209da 100644
--- a/packages/@jsii/kernel/src/link.ts
+++ b/packages/@jsii/kernel/src/link.ts
@@ -1,5 +1,19 @@
-import { copyFileSync, linkSync, mkdirSync, readdirSync, statSync } from 'fs';
-import { join } from 'path';
+import {
+  copyFileSync,
+  linkSync,
+  mkdirSync,
+  readdirSync,
+  statSync,
+  symlinkSync,
+} from 'fs';
+import { dirname, join } from 'path';
+
+/**
+ * If `node` is started with `--preserve-symlinks`, the module loaded will
+ * preserve symbolic links instead of resolving them, making it possible to
+ * symbolically link packages in place instead of fully copying them.
+ */
+const PRESERVE_SYMLINKS = process.execArgv.includes('--preserve-symlinks');
 
 /**
  * Creates directories containing hard links if possible, and falls back on
@@ -9,6 +23,12 @@ import { join } from 'path';
  * @param destination is the new file or directory to create.
  */
 export function link(existing: string, destination: string): void {
+  if (PRESERVE_SYMLINKS) {
+    mkdirSync(dirname(destination), { recursive: true });
+    symlinkSync(existing, destination);
+    return;
+  }
+
   const stat = statSync(existing);
   if (!stat.isDirectory()) {
     try {
diff --git a/packages/@jsii/kernel/src/objects.ts b/packages/@jsii/kernel/src/objects.ts
index 7c5ce1d3cd..3961ac4125 100644
--- a/packages/@jsii/kernel/src/objects.ts
+++ b/packages/@jsii/kernel/src/objects.ts
@@ -16,15 +16,30 @@ const OBJID_SYMBOL = Symbol.for('$__jsii__objid__$');
 const IFACES_SYMBOL = Symbol.for('$__jsii__interfaces__$');
 
 /**
- * Symbol we use to tag constructors that are exported from a JSII module.
+ * Symbol we use to tag constructors that are exported from a jsii module.
  */
 const JSII_TYPE_FQN_SYMBOL = Symbol('$__jsii__fqn__$');
 
-interface ManagedConstructor {
-  readonly [JSII_TYPE_FQN_SYMBOL]: string;
-}
+/**
+ * Symbol under which jsii runtime type information is stored.
+ */
+const JSII_RTTI_SYMBOL = Symbol.for('jsii.rtti');
 
-type MaybeManagedConstructor = Partial<ManagedConstructor>;
+/**
+ * Exported constructors processed by the jsii compiler have runtime type
+ * information woven into them under the `[JSII_RTTI]` symbol property.
+ */
+interface MaybeManagedConstructor {
+  readonly [JSII_RTTI_SYMBOL]?: {
+    /** The fully qualified name of the jsii type. */
+    readonly fqn: spec.FQN;
+    /** The version of the assembly that declared this type. */
+    readonly version: string;
+  };
+
+  /** The resolved JSII type FQN for this type. This is set only after resolution */
+  readonly [JSII_TYPE_FQN_SYMBOL]?: spec.FQN;
+}
 
 /**
  * Get the JSII fqn for an object (if available)
@@ -32,9 +47,37 @@ type MaybeManagedConstructor = Partial<ManagedConstructor>;
  * This will return something if the object was constructed from a JSII-enabled
  * class/constructor, or if a literal object was annotated with type
  * information.
+ *
+ * @param obj the object for which a jsii FQN is requested.
+ * @param isVisibleType a function that determines if a type is visible.
  */
-export function jsiiTypeFqn(obj: any): string | undefined {
-  return (obj.constructor as MaybeManagedConstructor)[JSII_TYPE_FQN_SYMBOL];
+export function jsiiTypeFqn(
+  obj: any,
+  isVisibleType: (fqn: spec.FQN) => boolean,
+): spec.FQN | undefined {
+  const ctor = obj.constructor as MaybeManagedConstructor;
+
+  // We've already resolved for this type, return the cached value.
+  if (ctor[JSII_TYPE_FQN_SYMBOL] != null) {
+    return ctor[JSII_TYPE_FQN_SYMBOL];
+  }
+
+  let curr = ctor;
+  while (curr[JSII_RTTI_SYMBOL]?.fqn) {
+    if (isVisibleType(curr[JSII_RTTI_SYMBOL].fqn)) {
+      const fqn = curr[JSII_RTTI_SYMBOL].fqn;
+
+      tagJsiiConstructor(curr, fqn);
+      tagJsiiConstructor(ctor, fqn);
+
+      return fqn;
+    }
+
+    // Walk up the prototype chain...
+    curr = Object.getPrototypeOf(curr);
+  }
+
+  return undefined;
 }
 
 /**
@@ -94,10 +137,11 @@ function tagObject(obj: unknown, objid: string, interfaces?: string[]) {
 /**
  * Set the JSII FQN for classes produced by a given constructor
  */
-export function tagJsiiConstructor(constructor: any, fqn: string) {
+export function tagJsiiConstructor(constructor: any, fqn: spec.FQN) {
   if (Object.prototype.hasOwnProperty.call(constructor, JSII_TYPE_FQN_SYMBOL)) {
-    return assert(
-      constructor[JSII_TYPE_FQN_SYMBOL] === fqn,
+    return assert.strictEqual(
+      constructor[JSII_TYPE_FQN_SYMBOL],
+      fqn,
       `Unable to register ${constructor.name} as ${fqn}: it is already registerd with FQN ${constructor[JSII_TYPE_FQN_SYMBOL]}`,
     );
   }
@@ -119,11 +163,11 @@ export function tagJsiiConstructor(constructor: any, fqn: string) {
  * type.
  */
 export class ObjectTable {
-  readonly #resolveType: (fqn: string) => spec.Type;
+  readonly #resolveType: (fqn: spec.FQN) => spec.Type;
   readonly #objects = new Map<string, RegisteredObject>();
   #nextid = 10000;
 
-  public constructor(resolveType: (fqn: string) => spec.Type) {
+  public constructor(resolveType: (fqn: spec.FQN) => spec.Type) {
     this.#resolveType = resolveType;
   }
 
@@ -134,8 +178,8 @@ export class ObjectTable {
    */
   public registerObject(
     obj: unknown,
-    fqn: string,
-    interfaces?: string[],
+    fqn: spec.FQN,
+    interfaces?: spec.FQN[],
   ): api.ObjRef {
     if (fqn === undefined) {
       throw new JsiiFault('FQN cannot be undefined');
@@ -227,14 +271,14 @@ export class ObjectTable {
     return this.#objects.size;
   }
 
-  #makeId(fqn: string) {
+  #makeId(fqn: spec.FQN) {
     return `${fqn}@${this.#nextid++}`;
   }
 
   #removeRedundant(
-    interfaces: string[] | undefined,
-    fqn: string,
-  ): string[] | undefined {
+    interfaces: spec.FQN[] | undefined,
+    fqn: spec.FQN,
+  ): spec.FQN[] | undefined {
     if (!interfaces || interfaces.length === 0) {
       return undefined;
     }
@@ -257,19 +301,19 @@ export class ObjectTable {
 
 export interface RegisteredObject {
   instance: any;
-  fqn: string;
-  interfaces?: string[];
+  fqn: spec.FQN;
+  interfaces?: spec.FQN[];
 }
 
 class InterfaceCollection implements Iterable<string> {
-  readonly #resolveType: (fqn: string) => spec.Type;
-  readonly #interfaces = new Set<string>();
+  readonly #resolveType: (fqn: spec.FQN) => spec.Type;
+  readonly #interfaces = new Set<spec.FQN>();
 
-  public constructor(resolveType: (fqn: string) => spec.Type) {
+  public constructor(resolveType: (fqn: spec.FQN) => spec.Type) {
     this.#resolveType = resolveType;
   }
 
-  public addFromClass(fqn: string): void {
+  public addFromClass(fqn: spec.FQN): void {
     const ti = this.#resolveType(fqn);
     if (!spec.isClassType(ti)) {
       throw new JsiiFault(
@@ -290,7 +334,7 @@ class InterfaceCollection implements Iterable<string> {
     }
   }
 
-  public addFromInterface(fqn: string): void {
+  public addFromInterface(fqn: spec.FQN): void {
     const ti = this.#resolveType(fqn);
     if (!spec.isInterfaceType(ti)) {
       throw new JsiiFault(
diff --git a/packages/@jsii/kernel/src/serialization.test.ts b/packages/@jsii/kernel/src/serialization.test.ts
index f7e47cf6ff..140511245f 100644
--- a/packages/@jsii/kernel/src/serialization.test.ts
+++ b/packages/@jsii/kernel/src/serialization.test.ts
@@ -21,12 +21,16 @@ const TYPE_STRING: OptionalValue = {
 };
 const TYPE_VOID = 'void';
 
+const isVisibleType: SerializerHost['isVisibleType'] = jest
+  .fn()
+  .mockName('host.isVisibleType');
 const lookupType: SerializerHost['lookupType'] = jest
   .fn()
   .mockName('host.lookupType');
 const host: SerializerHost = {
   debug: jest.fn().mockName('host.debug'),
   findSymbol: jest.fn().mockName('host.findSymbol'),
+  isVisibleType,
   lookupType,
   objects: new ObjectTable(lookupType),
 };
diff --git a/packages/@jsii/kernel/src/serialization.ts b/packages/@jsii/kernel/src/serialization.ts
index 27b6be1a99..95c3779957 100644
--- a/packages/@jsii/kernel/src/serialization.ts
+++ b/packages/@jsii/kernel/src/serialization.ts
@@ -91,14 +91,16 @@ export const enum SerializationClass {
   Any = 'Any',
 }
 
-type TypeLookup = (fqn: spec.FQN) => spec.Type;
-type SymbolLookup = (fqn: spec.FQN) => any;
+type FindSymbol = (fqn: spec.FQN) => any;
+type IsVisibleType = (fqn: spec.FQN) => boolean;
+type LookupType = (fqn: spec.FQN) => spec.Type;
 
 export interface SerializerHost {
   readonly objects: ObjectTable;
   debug(...args: any[]): void;
-  lookupType(fqn: string): spec.Type;
-  findSymbol(fqn: spec.FQN): any;
+  isVisibleType: IsVisibleType;
+  lookupType: LookupType;
+  findSymbol: FindSymbol;
 }
 
 interface Serializer {
@@ -135,20 +137,24 @@ export const SERIALIZERS: { [k: string]: Serializer } = {
 
   // ----------------------------------------------------------------------
   [SerializationClass.Date]: {
-    serialize(value, optionalValue): WireDate | undefined {
-      if (nullAndOk(value, optionalValue)) {
+    serialize(value, optionalValue, host): WireDate | undefined {
+      if (nullAndOk(value, optionalValue, host)) {
         return undefined;
       }
       assert(optionalValue !== VOID, 'Encountered unexpected void type!');
 
       if (!isDate(value)) {
-        throw new SerializationError(`Value is not an instance of Date`, value);
+        throw new SerializationError(
+          `Value is not an instance of Date`,
+          value,
+          host,
+        );
       }
       return serializeDate(value);
     },
 
-    deserialize(value, optionalValue) {
-      if (nullAndOk(value, optionalValue)) {
+    deserialize(value, optionalValue, host) {
+      if (nullAndOk(value, optionalValue, host)) {
         return undefined;
       }
 
@@ -156,6 +162,7 @@ export const SERIALIZERS: { [k: string]: Serializer } = {
         throw new SerializationError(
           `Value does not have the "${TOKEN_DATE}" key`,
           value,
+          host,
         );
       }
       return deserializeDate(value);
@@ -164,8 +171,8 @@ export const SERIALIZERS: { [k: string]: Serializer } = {
 
   // ----------------------------------------------------------------------
   [SerializationClass.Scalar]: {
-    serialize(value, optionalValue) {
-      if (nullAndOk(value, optionalValue)) {
+    serialize(value, optionalValue, host) {
+      if (nullAndOk(value, optionalValue, host)) {
         return undefined;
       }
       assert(optionalValue !== VOID, 'Encountered unexpected void type!');
@@ -176,19 +183,21 @@ export const SERIALIZERS: { [k: string]: Serializer } = {
         throw new SerializationError(
           `Value is not a ${spec.describeTypeReference(optionalValue.type)}`,
           value,
+          host,
         );
       }
       if (typeof value !== primitiveType.primitive) {
         throw new SerializationError(
           `Value is not a ${spec.describeTypeReference(optionalValue.type)}`,
           value,
+          host,
         );
       }
       return value;
     },
 
-    deserialize(value, optionalValue) {
-      if (nullAndOk(value, optionalValue)) {
+    deserialize(value, optionalValue, host) {
+      if (nullAndOk(value, optionalValue, host)) {
         return undefined;
       }
       assert(optionalValue !== VOID, 'Encountered unexpected void type!');
@@ -199,12 +208,14 @@ export const SERIALIZERS: { [k: string]: Serializer } = {
         throw new SerializationError(
           `Value is not a ${spec.describeTypeReference(optionalValue.type)}`,
           value,
+          host,
         );
       }
       if (typeof value !== primitiveType.primitive) {
         throw new SerializationError(
           `Value is not a ${spec.describeTypeReference(optionalValue.type)}`,
           value,
+          host,
         );
       }
 
@@ -214,9 +225,9 @@ export const SERIALIZERS: { [k: string]: Serializer } = {
 
   // ----------------------------------------------------------------------
   [SerializationClass.Json]: {
-    serialize(value, optionalValue) {
+    serialize(value, optionalValue, host) {
       // /!\ Top-level "null" will turn to undefined, but any null nested in the value is valid JSON, so it'll stay!
-      if (nullAndOk(value, optionalValue)) {
+      if (nullAndOk(value, optionalValue, host)) {
         return undefined;
       }
 
@@ -225,7 +236,7 @@ export const SERIALIZERS: { [k: string]: Serializer } = {
     },
     deserialize(value, optionalValue, host) {
       // /!\ Top-level "null" will turn to undefined, but any null nested in the value is valid JSON, so it'll stay!
-      if (nullAndOk(value, optionalValue)) {
+      if (nullAndOk(value, optionalValue, host)) {
         return undefined;
       }
 
@@ -257,7 +268,7 @@ export const SERIALIZERS: { [k: string]: Serializer } = {
         return value.map(mapJsonValue);
       }
 
-      return mapValues(value, mapJsonValue);
+      return mapValues(value, mapJsonValue, host);
 
       function mapJsonValue(toMap: any, key: string | number) {
         if (toMap == null) {
@@ -277,13 +288,17 @@ export const SERIALIZERS: { [k: string]: Serializer } = {
   // ----------------------------------------------------------------------
   [SerializationClass.Enum]: {
     serialize(value, optionalValue, host): WireEnum | undefined {
-      if (nullAndOk(value, optionalValue)) {
+      if (nullAndOk(value, optionalValue, host)) {
         return undefined;
       }
       assert(optionalValue !== VOID, 'Encountered unexpected void type!');
 
       if (typeof value !== 'string' && typeof value !== 'number') {
-        throw new SerializationError(`Value is not a string or number`, value);
+        throw new SerializationError(
+          `Value is not a string or number`,
+          value,
+          host,
+        );
       }
 
       host.debug('Serializing enum');
@@ -297,12 +312,13 @@ export const SERIALIZERS: { [k: string]: Serializer } = {
             enumType,
           )}`,
           value,
+          host,
         );
       }
       return { [TOKEN_ENUM]: `${enumType.fqn}/${enumEntry[0]}` };
     },
     deserialize(value, optionalValue, host) {
-      if (nullAndOk(value, optionalValue)) {
+      if (nullAndOk(value, optionalValue, host)) {
         return undefined;
       }
 
@@ -310,23 +326,24 @@ export const SERIALIZERS: { [k: string]: Serializer } = {
         throw new SerializationError(
           `Value does not have the "${TOKEN_ENUM}" key`,
           value,
+          host,
         );
       }
 
-      return deserializeEnum(value, host.findSymbol);
+      return deserializeEnum(value, host);
     },
   },
 
   // ----------------------------------------------------------------------
   [SerializationClass.Array]: {
     serialize(value, optionalValue, host) {
-      if (nullAndOk(value, optionalValue)) {
+      if (nullAndOk(value, optionalValue, host)) {
         return undefined;
       }
       assert(optionalValue !== VOID, 'Encountered unexpected void type!');
 
       if (!Array.isArray(value)) {
-        throw new SerializationError(`Value is not an array`, value);
+        throw new SerializationError(`Value is not an array`, value, host);
       }
 
       const arrayType = optionalValue.type as spec.CollectionTypeReference;
@@ -342,13 +359,13 @@ export const SERIALIZERS: { [k: string]: Serializer } = {
       );
     },
     deserialize(value, optionalValue, host) {
-      if (nullAndOk(value, optionalValue)) {
+      if (nullAndOk(value, optionalValue, host)) {
         return undefined;
       }
       assert(optionalValue !== VOID, 'Encountered unexpected void type!');
 
       if (!Array.isArray(value)) {
-        throw new SerializationError(`Value is not an array`, value);
+        throw new SerializationError(`Value is not an array`, value, host);
       }
 
       const arrayType = optionalValue.type as spec.CollectionTypeReference;
@@ -368,21 +385,24 @@ export const SERIALIZERS: { [k: string]: Serializer } = {
   // ----------------------------------------------------------------------
   [SerializationClass.Map]: {
     serialize(value, optionalValue, host) {
-      if (nullAndOk(value, optionalValue)) {
+      if (nullAndOk(value, optionalValue, host)) {
         return undefined;
       }
       assert(optionalValue !== VOID, 'Encountered unexpected void type!');
 
       const mapType = optionalValue.type as spec.CollectionTypeReference;
       return {
-        [TOKEN_MAP]: mapValues(value, (v, key) =>
-          process(
-            host,
-            'serialize',
-            v,
-            { type: mapType.collection.elementtype },
-            `key ${inspect(key)}`,
-          ),
+        [TOKEN_MAP]: mapValues(
+          value,
+          (v, key) =>
+            process(
+              host,
+              'serialize',
+              v,
+              { type: mapType.collection.elementtype },
+              `key ${inspect(key)}`,
+            ),
+          host,
         ),
       };
     },
@@ -392,7 +412,7 @@ export const SERIALIZERS: { [k: string]: Serializer } = {
       host,
       { allowNullishMapValue = false } = {},
     ) {
-      if (nullAndOk(value, optionalValue)) {
+      if (nullAndOk(value, optionalValue, host)) {
         return undefined;
       }
       assert(optionalValue !== VOID, 'Encountered unexpected void type!');
@@ -400,7 +420,25 @@ export const SERIALIZERS: { [k: string]: Serializer } = {
       const mapType = optionalValue.type as spec.CollectionTypeReference;
       if (!isWireMap(value)) {
         // Compatibility mode with older versions that didn't wrap in [TOKEN_MAP]
-        return mapValues(value, (v, key) =>
+        return mapValues(
+          value,
+          (v, key) =>
+            process(
+              host,
+              'deserialize',
+              v,
+              {
+                optional: allowNullishMapValue,
+                type: mapType.collection.elementtype,
+              },
+              `key ${inspect(key)}`,
+            ),
+          host,
+        );
+      }
+      const result = mapValues(
+        value[TOKEN_MAP],
+        (v, key) =>
           process(
             host,
             'deserialize',
@@ -411,19 +449,7 @@ export const SERIALIZERS: { [k: string]: Serializer } = {
             },
             `key ${inspect(key)}`,
           ),
-        );
-      }
-      const result = mapValues(value[TOKEN_MAP], (v, key) =>
-        process(
-          host,
-          'deserialize',
-          v,
-          {
-            optional: allowNullishMapValue,
-            type: mapType.collection.elementtype,
-          },
-          `key ${inspect(key)}`,
-        ),
+        host,
       );
       Object.defineProperty(result, SYMBOL_WIRE_TYPE, {
         configurable: false,
@@ -438,17 +464,17 @@ export const SERIALIZERS: { [k: string]: Serializer } = {
   // ----------------------------------------------------------------------
   [SerializationClass.Struct]: {
     serialize(value, optionalValue, host) {
-      if (nullAndOk(value, optionalValue)) {
+      if (nullAndOk(value, optionalValue, host)) {
         return undefined;
       }
       assert(optionalValue !== VOID, 'Encountered unexpected void type!');
 
       if (typeof value !== 'object' || value == null || value instanceof Date) {
-        throw new SerializationError(`Value is not an object`, value);
+        throw new SerializationError(`Value is not an object`, value, host);
       }
 
       if (Array.isArray(value)) {
-        throw new SerializationError(`Value is an array`, value);
+        throw new SerializationError(`Value is an array`, value, host);
       }
 
       /*
@@ -476,13 +502,13 @@ export const SERIALIZERS: { [k: string]: Serializer } = {
         // Treat empty structs as `undefined` (see https://github.com/aws/jsii/issues/411)
         value = undefined;
       }
-      if (nullAndOk(value, optionalValue)) {
+      if (nullAndOk(value, optionalValue, host)) {
         return undefined;
       }
       assert(optionalValue !== VOID, 'Encountered unexpected void type!');
 
       if (typeof value !== 'object' || value == null) {
-        throw new SerializationError(`Value is not an object`, value);
+        throw new SerializationError(`Value is not an object`, value, host);
       }
 
       const namedType = host.lookupType(
@@ -494,6 +520,7 @@ export const SERIALIZERS: { [k: string]: Serializer } = {
         throw new SerializationError(
           'Value is an array (varargs may have been incorrectly supplied)',
           value,
+          host,
         );
       }
 
@@ -510,6 +537,7 @@ export const SERIALIZERS: { [k: string]: Serializer } = {
           host.objects.findObject(value).instance,
           namedType.fqn,
           props,
+          host,
         );
       }
 
@@ -519,6 +547,7 @@ export const SERIALIZERS: { [k: string]: Serializer } = {
           throw new SerializationError(
             `Wired struct has type '${fqn}', which does not match expected type`,
             value,
+            host,
           );
         }
         value = data;
@@ -529,38 +558,42 @@ export const SERIALIZERS: { [k: string]: Serializer } = {
         value = value[api.TOKEN_MAP];
       }
 
-      value = validateRequiredProps(value as any, namedType.fqn, props);
+      value = validateRequiredProps(value as any, namedType.fqn, props, host);
 
       // Return a dict COPY, we have by-value semantics anyway.
-      return mapValues(value, (v, key) => {
-        if (!props[key]) {
-          return undefined;
-        } // Don't map if unknown property
-        return process(
-          host,
-          'deserialize',
-          v,
-          props[key],
-          `key ${inspect(key)}`,
-        );
-      });
+      return mapValues(
+        value,
+        (v, key) => {
+          if (!props[key]) {
+            return undefined;
+          } // Don't map if unknown property
+          return process(
+            host,
+            'deserialize',
+            v,
+            props[key],
+            `key ${inspect(key)}`,
+          );
+        },
+        host,
+      );
     },
   },
 
   // ----------------------------------------------------------------------
   [SerializationClass.ReferenceType]: {
     serialize(value, optionalValue, host): ObjRef | undefined {
-      if (nullAndOk(value, optionalValue)) {
+      if (nullAndOk(value, optionalValue, host)) {
         return undefined;
       }
       assert(optionalValue !== VOID, 'Encountered unexpected void type!');
 
       if (typeof value !== 'object' || value == null || Array.isArray(value)) {
-        throw new SerializationError(`Value is not an object`, value);
+        throw new SerializationError(`Value is not an object`, value, host);
       }
 
       if (value instanceof Date) {
-        throw new SerializationError(`Value is a Date`, value);
+        throw new SerializationError(`Value is a Date`, value, host);
       }
 
       const expectedType = host.lookupType(
@@ -570,13 +603,13 @@ export const SERIALIZERS: { [k: string]: Serializer } = {
         ? [expectedType.fqn]
         : undefined;
       const jsiiType =
-        jsiiTypeFqn(value) ??
+        jsiiTypeFqn(value, host.isVisibleType) ??
         (spec.isClassType(expectedType) ? expectedType.fqn : EMPTY_OBJECT_FQN);
 
       return host.objects.registerObject(value, jsiiType, interfaces);
     },
     deserialize(value, optionalValue, host) {
-      if (nullAndOk(value, optionalValue)) {
+      if (nullAndOk(value, optionalValue, host)) {
         return undefined;
       }
       assert(optionalValue !== VOID, 'Encountered unexpected void type!');
@@ -588,6 +621,7 @@ export const SERIALIZERS: { [k: string]: Serializer } = {
         throw new SerializationError(
           `Value does not have the "${TOKEN_REF}" key`,
           value,
+          host,
         );
       }
 
@@ -611,6 +645,7 @@ export const SERIALIZERS: { [k: string]: Serializer } = {
               declaredType,
             )}`,
             value,
+            host,
           );
         }
       }
@@ -651,6 +686,7 @@ export const SERIALIZERS: { [k: string]: Serializer } = {
         throw new SerializationError(
           'Functions cannot be passed across language boundaries',
           value,
+          host,
         );
       }
 
@@ -658,6 +694,7 @@ export const SERIALIZERS: { [k: string]: Serializer } = {
         throw new SerializationError(
           `A jsii kernel assumption was violated: value is not an object`,
           value,
+          host,
         );
       }
 
@@ -686,6 +723,7 @@ export const SERIALIZERS: { [k: string]: Serializer } = {
         throw new SerializationError(
           'Set and Map instances cannot be sent across the language boundary',
           value,
+          host,
         );
       }
 
@@ -700,7 +738,7 @@ export const SERIALIZERS: { [k: string]: Serializer } = {
       // If this is or should be a reference type, pass or make the reference
       // (Like regular reftype serialization, but without the type derivation to an interface)
       const jsiiType =
-        jsiiTypeFqn(value) ??
+        jsiiTypeFqn(value, host.isVisibleType) ??
         (isByReferenceOnly(value) ? EMPTY_OBJECT_FQN : undefined);
       if (jsiiType) {
         return host.objects.registerObject(value, jsiiType);
@@ -712,14 +750,17 @@ export const SERIALIZERS: { [k: string]: Serializer } = {
       // We will serialize by-value, but recurse for serialization so that if
       // the object contains reference objects, they will be serialized appropriately.
       // (Basically, serialize anything else as a map of 'any').
-      return mapValues(value, (v, key) =>
-        process(
-          host,
-          'serialize',
-          v,
-          { type: spec.CANONICAL_ANY },
-          `key ${inspect(key)}`,
-        ),
+      return mapValues(
+        value,
+        (v, key) =>
+          process(
+            host,
+            'serialize',
+            v,
+            { type: spec.CANONICAL_ANY },
+            `key ${inspect(key)}`,
+          ),
+        host,
       );
     },
 
@@ -751,7 +792,7 @@ export const SERIALIZERS: { [k: string]: Serializer } = {
 
       if (isWireEnum(value)) {
         host.debug('ANY is an Enum');
-        return deserializeEnum(value, host.findSymbol);
+        return deserializeEnum(value, host);
       }
       if (isWireMap(value)) {
         host.debug('ANY is a Map');
@@ -787,14 +828,17 @@ export const SERIALIZERS: { [k: string]: Serializer } = {
 
       // At this point again, deserialize by-value.
       host.debug('ANY is a Map');
-      return mapValues(value, (v, key) =>
-        process(
-          host,
-          'deserialize',
-          v,
-          { type: spec.CANONICAL_ANY },
-          `key ${inspect(key)}`,
-        ),
+      return mapValues(
+        value,
+        (v, key) =>
+          process(
+            host,
+            'deserialize',
+            v,
+            { type: spec.CANONICAL_ANY },
+            `key ${inspect(key)}`,
+          ),
+        host,
       );
     },
   },
@@ -808,24 +852,26 @@ function deserializeDate(value: WireDate): Date {
   return new Date(value[TOKEN_DATE]);
 }
 
-function deserializeEnum(value: WireEnum, lookup: SymbolLookup) {
+function deserializeEnum(value: WireEnum, host: SerializerHost) {
   const enumLocator = value[TOKEN_ENUM];
   const sep = enumLocator.lastIndexOf('/');
   if (sep === -1) {
     throw new SerializationError(
       `Invalid enum token value ${inspect(enumLocator)}`,
       value,
+      host,
     );
   }
 
   const typeName = enumLocator.slice(0, sep);
   const valueName = enumLocator.slice(sep + 1);
 
-  const enumValue = lookup(typeName)[valueName];
+  const enumValue = host.findSymbol(typeName)[valueName];
   if (enumValue === undefined) {
     throw new SerializationError(
       `No such enum member: ${inspect(valueName)}`,
       value,
+      host,
     );
   }
   return enumValue;
@@ -843,7 +889,7 @@ export interface TypeSerialization {
  */
 export function serializationType(
   typeRef: OptionalValueOrVoid,
-  lookup: TypeLookup,
+  lookup: LookupType,
 ): TypeSerialization[] {
   assert(
     typeRef != null,
@@ -909,7 +955,11 @@ export function serializationType(
   return [{ serializationClass: SerializationClass.ReferenceType, typeRef }];
 }
 
-function nullAndOk(x: unknown, type: OptionalValueOrVoid): boolean {
+function nullAndOk(
+  x: unknown,
+  type: OptionalValueOrVoid,
+  host: SerializerHost,
+): boolean {
   if (x != null) {
     return false;
   }
@@ -918,6 +968,7 @@ function nullAndOk(x: unknown, type: OptionalValueOrVoid): boolean {
     throw new SerializationError(
       `A value is required (type is non-optional)`,
       x,
+      host,
     );
   }
 
@@ -951,13 +1002,14 @@ function flatMap<T, U>(xs: T[], fn: (x: T) => U[]): U[] {
 function mapValues(
   value: unknown,
   fn: (value: any, field: string) => any,
+  host: SerializerHost,
 ): { [key: string]: any } {
   if (typeof value !== 'object' || value == null) {
-    throw new SerializationError(`Value is not an object`, value);
+    throw new SerializationError(`Value is not an object`, value, host);
   }
 
   if (Array.isArray(value)) {
-    throw new SerializationError(`Value is an array`, value);
+    throw new SerializationError(`Value is an array`, value, host);
   }
 
   const out: { [key: string]: any } = {};
@@ -973,7 +1025,7 @@ function mapValues(
 
 function propertiesOf(
   t: spec.Type,
-  lookup: TypeLookup,
+  lookup: LookupType,
 ): { [name: string]: spec.Property } {
   if (!spec.isClassOrInterfaceType(t)) {
     return {};
@@ -1009,7 +1061,7 @@ function propertiesOf(
 function isAssignable(
   actualTypeFqn: string,
   requiredType: spec.NamedTypeReference,
-  lookup: TypeLookup,
+  lookup: LookupType,
 ): boolean {
   // The empty object is assignable to everything
   if (actualTypeFqn === EMPTY_OBJECT_FQN) {
@@ -1042,6 +1094,7 @@ function validateRequiredProps(
   actualProps: { [key: string]: any },
   typeName: string,
   specProps: { [key: string]: spec.Property },
+  host: SerializerHost,
 ) {
   // Check for required properties
   const missingRequiredProps = Object.keys(specProps)
@@ -1054,6 +1107,7 @@ function validateRequiredProps(
         .map((p) => inspect(p))
         .join(', ')}`,
       actualProps,
+      host,
     );
   }
 
@@ -1143,6 +1197,7 @@ export function process(
   throw new SerializationError(
     `${titleize(context)}: Unable to ${serde} value as ${optionalTypeDescr}`,
     value,
+    host,
     errors,
     { renderValue: true },
   );
@@ -1163,6 +1218,7 @@ export class SerializationError extends Error {
   public constructor(
     message: string,
     public readonly value: unknown,
+    { isVisibleType }: { readonly isVisibleType: (fqn: string) => boolean },
     public readonly causes: readonly any[] = [],
     { renderValue = false }: { renderValue?: boolean } = {},
   ) {
@@ -1175,6 +1231,7 @@ export class SerializationError extends Error {
                 causes.length > 0 ? '\u{251C}' : '\u{2570}'
               }\u{2500}\u{2500} \u{1F6D1} Failing value is ${describeTypeOf(
                 value,
+                isVisibleType,
               )}`,
               ...(value == null
                 ? []
@@ -1206,7 +1263,10 @@ export class SerializationError extends Error {
   }
 }
 
-function describeTypeOf(value: unknown) {
+function describeTypeOf(
+  value: unknown,
+  isVisibleType: (fqn: string) => boolean,
+) {
   const type = typeof value;
   switch (type) {
     case 'object':
@@ -1218,7 +1278,7 @@ function describeTypeOf(value: unknown) {
         return 'an array';
       }
 
-      const fqn = jsiiTypeFqn(value as object);
+      const fqn = jsiiTypeFqn(value as object, isVisibleType);
       if (fqn != null && fqn !== EMPTY_OBJECT_FQN) {
         return `an instance of ${fqn}`;
       }
diff --git a/packages/@jsii/kernel/src/serialization.ux.test.ts b/packages/@jsii/kernel/src/serialization.ux.test.ts
index 5bb8e0e397..35d207b61d 100644
--- a/packages/@jsii/kernel/src/serialization.ux.test.ts
+++ b/packages/@jsii/kernel/src/serialization.ux.test.ts
@@ -13,6 +13,9 @@ expect.addSnapshotSerializer({
 const findSymbol: jest.MockedFn<SerializerHost['findSymbol']> = jest
   .fn()
   .mockName('SerializerHost.findSymbol');
+const isVisibleType: jest.MockedFn<SerializerHost['isVisibleType']> = jest
+  .fn()
+  .mockName('SerializerHost.isVisibleType');
 const lookupType: jest.MockedFn<SerializerHost['lookupType']> = jest
   .fn()
   .mockName('SerializerHost.lookupType');
@@ -21,6 +24,7 @@ const objects = new ObjectTable(lookupType);
 const host: SerializerHost = {
   debug: () => void undefined,
   findSymbol,
+  isVisibleType,
   lookupType,
   objects,
 };
diff --git a/packages/@jsii/kernel/src/tar-cache/index.ts b/packages/@jsii/kernel/src/tar-cache/index.ts
index b1cf0f5319..b94939f835 100644
--- a/packages/@jsii/kernel/src/tar-cache/index.ts
+++ b/packages/@jsii/kernel/src/tar-cache/index.ts
@@ -24,7 +24,8 @@ export interface ExtractResult {
 }
 
 let packageCacheEnabled =
-  process.env.JSII_RUNTIME_PACKAGE_CACHE?.toLocaleLowerCase() === 'enabled';
+  (process.env.JSII_RUNTIME_PACKAGE_CACHE?.toLocaleLowerCase() ?? 'enabled') ===
+  'enabled';
 
 /**
  * Extracts the content of a tarball, possibly caching it on disk.
@@ -41,7 +42,6 @@ export function extract(
   options: ExtractOptions,
   ...comments: readonly string[]
 ): ExtractResult {
-  mkdirSync(outDir, { recursive: true });
   try {
     return (packageCacheEnabled ? extractViaCache : extractToOutDir)(
       file,
@@ -100,6 +100,9 @@ function extractToOutDir(
   cwd: string,
   options: ExtractOptions = {},
 ): { cache?: undefined } {
+  // The output directory must already exist...
+  mkdirSync(cwd, { recursive: true });
+
   // !!!IMPORTANT!!!
   // Extract directly into the final target directory, as certain antivirus
   // software configurations on Windows will make a `renameSync` operation
diff --git a/packages/@jsii/python-runtime/src/jsii/_kernel/providers/process.py b/packages/@jsii/python-runtime/src/jsii/_kernel/providers/process.py
index f595ebe6d1..0e6fb9fb64 100644
--- a/packages/@jsii/python-runtime/src/jsii/_kernel/providers/process.py
+++ b/packages/@jsii/python-runtime/src/jsii/_kernel/providers/process.py
@@ -313,6 +313,8 @@ def handshake(self) -> None:
         # TODO: Replace with proper error.
         assert (
             resp.hello == f"@jsii/runtime@{__jsii_runtime_version__}"
+            # Transparently allow development versions of the runtime to be used.
+            or resp.hello == f"@jsii/runtime@0.0.0"
         ), f"Invalid JSII Runtime Version: {resp.hello!r}"
 
     def send(
diff --git a/packages/@jsii/runtime/bin/jsii-runtime.ts b/packages/@jsii/runtime/bin/jsii-runtime.ts
index 111bb70e95..0b4fa0347a 100644
--- a/packages/@jsii/runtime/bin/jsii-runtime.ts
+++ b/packages/@jsii/runtime/bin/jsii-runtime.ts
@@ -12,7 +12,13 @@ import { Duplex } from 'stream';
 // - FD#3 is the communication pipe to read & write jsii API messages
 const child = spawn(
   process.execPath,
-  [...process.execArgv, resolve(__dirname, '..', 'lib', 'program.js')],
+  [
+    ...process.execArgv,
+    // Instruct the module loader to NOT resolve symbolic links, so we don't
+    // have to copy modules around all the time (which is expensive to do).
+    '--preserve-symlinks',
+    resolve(__dirname, '..', 'lib', 'program.js'),
+  ],
   { stdio: ['ignore', 'pipe', 'pipe', 'pipe'] },
 );
 
diff --git a/packages/@jsii/runtime/lib/host.ts b/packages/@jsii/runtime/lib/host.ts
index fd1a1e5859..9e9b5f79c0 100644
--- a/packages/@jsii/runtime/lib/host.ts
+++ b/packages/@jsii/runtime/lib/host.ts
@@ -20,10 +20,12 @@ export class KernelHost {
       debug?: boolean;
       debugTiming?: boolean;
       noStack?: boolean;
+      validateAssemblies?: boolean;
     } = {},
   ) {
     this.kernel.traceEnabled = opts.debug ?? false;
     this.kernel.debugTimingEnabled = opts.debugTiming ?? false;
+    this.kernel.validateAssemblies = opts.validateAssemblies ?? false;
   }
 
   public run() {
diff --git a/packages/@jsii/runtime/lib/program.ts b/packages/@jsii/runtime/lib/program.ts
index 41a35cc5f4..ccdfdf1aea 100644
--- a/packages/@jsii/runtime/lib/program.ts
+++ b/packages/@jsii/runtime/lib/program.ts
@@ -9,6 +9,7 @@ const version = packageInfo.version;
 const noStack = !!process.env.JSII_NOSTACK;
 const debug = !!process.env.JSII_DEBUG;
 const debugTiming = !!process.env.JSII_DEBUG_TIMING;
+const validateAssemblies = !!process.env.JSII_VALIDATE_ASSEMBLIES;
 
 // This assumes FD#3 is opened for reading and writing. This is normally
 // performed by`bin/jsii-runtime.js`, and we will not be verifying this once
@@ -25,7 +26,12 @@ const stdio = new SyncStdio({
 });
 
 const inout = new InputOutput(stdio);
-const host = new KernelHost(inout, { debug, noStack, debugTiming });
+const host = new KernelHost(inout, {
+  debug,
+  noStack,
+  debugTiming,
+  validateAssemblies,
+});
 
 host.once('exit', process.exit.bind(process));
 
diff --git a/packages/@scope/jsii-calc-lib/lib/deprecation-removal.ts b/packages/@scope/jsii-calc-lib/lib/deprecation-removal.ts
index 75e18b6776..cfd01dfc7d 100644
--- a/packages/@scope/jsii-calc-lib/lib/deprecation-removal.ts
+++ b/packages/@scope/jsii-calc-lib/lib/deprecation-removal.ts
@@ -1,10 +1,23 @@
+export class VisibleBaseClass {
+  public readonly propertyPresent: boolean;
+
+  public constructor() {
+    this.propertyPresent = true;
+  }
+}
+
 export interface IInterface {
   method(): void;
 }
 
 /** @deprecated do not use me! */
-export class DeprecatedImplementation implements IInterface {
-  public method(): void { }
+export class DeprecatedImplementation
+  extends VisibleBaseClass
+  implements IInterface
+{
+  public method(): void {
+    /** NOOP */
+  }
 }
 
 export class InterfaceFactory {
@@ -12,5 +25,5 @@ export class InterfaceFactory {
     return new DeprecatedImplementation();
   }
 
-  private constructor() { }
+  private constructor() {}
 }
diff --git a/packages/@scope/jsii-calc-lib/test/assembly.jsii b/packages/@scope/jsii-calc-lib/test/assembly.jsii
index f19503b617..dfca777fbc 100644
--- a/packages/@scope/jsii-calc-lib/test/assembly.jsii
+++ b/packages/@scope/jsii-calc-lib/test/assembly.jsii
@@ -790,7 +790,7 @@
       "kind": "interface",
       "locationInModule": {
         "filename": "lib/deprecation-removal.ts",
-        "line": 1
+        "line": 9
       },
       "methods": [
         {
@@ -800,7 +800,7 @@
           },
           "locationInModule": {
             "filename": "lib/deprecation-removal.ts",
-            "line": 2
+            "line": 10
           },
           "name": "method"
         }
@@ -818,7 +818,7 @@
       "kind": "class",
       "locationInModule": {
         "filename": "lib/deprecation-removal.ts",
-        "line": 10
+        "line": 23
       },
       "methods": [
         {
@@ -827,7 +827,7 @@
           },
           "locationInModule": {
             "filename": "lib/deprecation-removal.ts",
-            "line": 11
+            "line": 24
           },
           "name": "create",
           "returns": {
@@ -842,6 +842,46 @@
       "namespace": "deprecationRemoval",
       "symbolId": "lib/deprecation-removal:InterfaceFactory"
     },
+    "@scope/jsii-calc-lib.deprecationRemoval.VisibleBaseClass": {
+      "assembly": "@scope/jsii-calc-lib",
+      "docs": {
+        "stability": "deprecated"
+      },
+      "fqn": "@scope/jsii-calc-lib.deprecationRemoval.VisibleBaseClass",
+      "initializer": {
+        "docs": {
+          "stability": "deprecated"
+        },
+        "locationInModule": {
+          "filename": "lib/deprecation-removal.ts",
+          "line": 4
+        }
+      },
+      "kind": "class",
+      "locationInModule": {
+        "filename": "lib/deprecation-removal.ts",
+        "line": 1
+      },
+      "name": "VisibleBaseClass",
+      "namespace": "deprecationRemoval",
+      "properties": [
+        {
+          "docs": {
+            "stability": "deprecated"
+          },
+          "immutable": true,
+          "locationInModule": {
+            "filename": "lib/deprecation-removal.ts",
+            "line": 2
+          },
+          "name": "propertyPresent",
+          "type": {
+            "primitive": "boolean"
+          }
+        }
+      ],
+      "symbolId": "lib/deprecation-removal:VisibleBaseClass"
+    },
     "@scope/jsii-calc-lib.submodule.IReflectable": {
       "assembly": "@scope/jsii-calc-lib",
       "docs": {
@@ -1067,5 +1107,5 @@
     }
   },
   "version": "0.0.0",
-  "fingerprint": "yrpQ+/ynmcWEtNZgCAeq2yp4JpEpln2V/fRhUc5uVUs="
+  "fingerprint": "o9wTL2Nj4gErRFWUIu9vurI1HEiTs0FLFa8hjfWpkHg="
 }
\ No newline at end of file
diff --git a/packages/jsii-pacmak/test/generated-code/__snapshots__/target-dotnet.test.js.snap b/packages/jsii-pacmak/test/generated-code/__snapshots__/target-dotnet.test.js.snap
index ddc5175c17..d6f10a8c69 100644
--- a/packages/jsii-pacmak/test/generated-code/__snapshots__/target-dotnet.test.js.snap
+++ b/packages/jsii-pacmak/test/generated-code/__snapshots__/target-dotnet.test.js.snap
@@ -1015,7 +1015,8 @@ exports[`Generated code for "@scope/jsii-calc-lib": <outDir>/ 1`] = `
        ┃        ┃     ┣━ 📄 BaseFor2647.cs
        ┃        ┃     ┣━ 📁 DeprecationRemoval
        ┃        ┃     ┃  ┣━ 📄 IInterface.cs
-       ┃        ┃     ┃  ┗━ 📄 InterfaceFactory.cs
+       ┃        ┃     ┃  ┣━ 📄 InterfaceFactory.cs
+       ┃        ┃     ┃  ┗━ 📄 VisibleBaseClass.cs
        ┃        ┃     ┣━ 📄 DiamondLeft.cs
        ┃        ┃     ┣━ 📄 DiamondRight.cs
        ┃        ┃     ┣━ 📄 EnumFromScopedModule.cs
@@ -1247,6 +1248,64 @@ namespace Amazon.JSII.Tests.CalculatorNamespace.LibNamespace.DeprecationRemoval
 
 `;
 
+exports[`Generated code for "@scope/jsii-calc-lib": <outDir>/dotnet/Amazon.JSII.Tests.CalculatorPackageId.LibPackageId/Amazon/JSII/Tests/CalculatorNamespace/LibNamespace/DeprecationRemoval/VisibleBaseClass.cs 1`] = `
+using Amazon.JSII.Runtime.Deputy;
+
+#pragma warning disable CS0672,CS0809,CS1591
+
+namespace Amazon.JSII.Tests.CalculatorNamespace.LibNamespace.DeprecationRemoval
+{
+    /// <remarks>
+    /// <strong>Stability</strong>: Deprecated
+    /// </remarks>
+    [JsiiClass(nativeType: typeof(Amazon.JSII.Tests.CalculatorNamespace.LibNamespace.DeprecationRemoval.VisibleBaseClass), fullyQualifiedName: "@scope/jsii-calc-lib.deprecationRemoval.VisibleBaseClass")]
+    [System.Obsolete()]
+    public class VisibleBaseClass : DeputyBase
+    {
+        /// <remarks>
+        /// <strong>Stability</strong>: Deprecated
+        /// </remarks>
+        [System.Obsolete()]
+        public VisibleBaseClass(): base(_MakeDeputyProps())
+        {
+        }
+
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        private static DeputyProps _MakeDeputyProps()
+        {
+            return new DeputyProps(System.Array.Empty<object?>());
+        }
+
+        /// <summary>Used by jsii to construct an instance of this class from a Javascript-owned object reference</summary>
+        /// <param name="reference">The Javascript-owned object reference</param>
+        [System.Obsolete()]
+        [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+        protected VisibleBaseClass(ByRefValue reference): base(reference)
+        {
+        }
+
+        /// <summary>Used by jsii to construct an instance of this class from DeputyProps</summary>
+        /// <param name="props">The deputy props</param>
+        [System.Obsolete()]
+        [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+        protected VisibleBaseClass(DeputyProps props): base(props)
+        {
+        }
+
+        /// <remarks>
+        /// <strong>Stability</strong>: Deprecated
+        /// </remarks>
+        [JsiiProperty(name: "propertyPresent", typeJson: "{\\"primitive\\":\\"boolean\\"}")]
+        [System.Obsolete()]
+        public virtual bool PropertyPresent
+        {
+            get => GetInstanceProperty<bool>()!;
+        }
+    }
+}
+
+`;
+
 exports[`Generated code for "@scope/jsii-calc-lib": <outDir>/dotnet/Amazon.JSII.Tests.CalculatorPackageId.LibPackageId/Amazon/JSII/Tests/CalculatorNamespace/LibNamespace/DiamondLeft.cs 1`] = `
 using Amazon.JSII.Runtime.Deputy;
 
diff --git a/packages/jsii-pacmak/test/generated-code/__snapshots__/target-go.test.js.snap b/packages/jsii-pacmak/test/generated-code/__snapshots__/target-go.test.js.snap
index 637fc8da65..a8de34ab7b 100644
--- a/packages/jsii-pacmak/test/generated-code/__snapshots__/target-go.test.js.snap
+++ b/packages/jsii-pacmak/test/generated-code/__snapshots__/target-go.test.js.snap
@@ -969,7 +969,8 @@ exports[`Generated code for "@scope/jsii-calc-lib": <outDir>/ 1`] = `
        ┣━ 📁 deprecationremoval
        ┃  ┣━ 📄 IInterface.go
        ┃  ┣━ 📄 InterfaceFactory.go
-       ┃  ┗━ 📄 main.go
+       ┃  ┣━ 📄 main.go
+       ┃  ┗━ 📄 VisibleBaseClass.go
        ┣━ 📄 DiamondLeft.go
        ┣━ 📄 DiamondRight.go
        ┣━ 📄 EnumFromScopedModule.go
@@ -2132,6 +2133,65 @@ func InterfaceFactory_Create() IInterface {
 }
 
 
+`;
+
+exports[`Generated code for "@scope/jsii-calc-lib": <outDir>/go/scopejsiicalclib/deprecationremoval/VisibleBaseClass.go 1`] = `
+package deprecationremoval
+
+import (
+	_jsii_ "github.com/aws/jsii-runtime-go/runtime"
+	_init_ "github.com/aws/jsii/jsii-calc/go/scopejsiicalclib/jsii"
+)
+
+// Deprecated.
+type VisibleBaseClass interface {
+	// Deprecated.
+	PropertyPresent() *bool
+}
+
+// The jsii proxy struct for VisibleBaseClass
+type jsiiProxy_VisibleBaseClass struct {
+	_ byte // padding
+}
+
+func (j *jsiiProxy_VisibleBaseClass) PropertyPresent() *bool {
+	var returns *bool
+	_jsii_.Get(
+		j,
+		"propertyPresent",
+		&returns,
+	)
+	return returns
+}
+
+
+// Deprecated.
+func NewVisibleBaseClass() VisibleBaseClass {
+	_init_.Initialize()
+
+	j := jsiiProxy_VisibleBaseClass{}
+
+	_jsii_.Create(
+		"@scope/jsii-calc-lib.deprecationRemoval.VisibleBaseClass",
+		nil, // no parameters
+		&j,
+	)
+
+	return &j
+}
+
+// Deprecated.
+func NewVisibleBaseClass_Override(v VisibleBaseClass) {
+	_init_.Initialize()
+
+	_jsii_.Create(
+		"@scope/jsii-calc-lib.deprecationRemoval.VisibleBaseClass",
+		nil, // no parameters
+		v,
+	)
+}
+
+
 `;
 
 exports[`Generated code for "@scope/jsii-calc-lib": <outDir>/go/scopejsiicalclib/deprecationremoval/main.go 1`] = `
@@ -2162,6 +2222,16 @@ func init() {
 			return &jsiiProxy_InterfaceFactory{}
 		},
 	)
+	_jsii_.RegisterClass(
+		"@scope/jsii-calc-lib.deprecationRemoval.VisibleBaseClass",
+		reflect.TypeOf((*VisibleBaseClass)(nil)).Elem(),
+		[]_jsii_.Member{
+			_jsii_.MemberProperty{JsiiProperty: "propertyPresent", GoGetter: "PropertyPresent"},
+		},
+		func() interface{} {
+			return &jsiiProxy_VisibleBaseClass{}
+		},
+	)
 }
 
 `;
diff --git a/packages/jsii-pacmak/test/generated-code/__snapshots__/target-java.test.js.snap b/packages/jsii-pacmak/test/generated-code/__snapshots__/target-java.test.js.snap
index 87b61f7be7..1b52ed4577 100644
--- a/packages/jsii-pacmak/test/generated-code/__snapshots__/target-java.test.js.snap
+++ b/packages/jsii-pacmak/test/generated-code/__snapshots__/target-java.test.js.snap
@@ -1444,7 +1444,8 @@ exports[`Generated code for "@scope/jsii-calc-lib": <outDir>/ 1`] = `
           ┃                    ┣━ 📄 BaseFor2647.java
           ┃                    ┣━ 📁 deprecation_removal
           ┃                    ┃  ┣━ 📄 IInterface.java
-          ┃                    ┃  ┗━ 📄 InterfaceFactory.java
+          ┃                    ┃  ┣━ 📄 InterfaceFactory.java
+          ┃                    ┃  ┗━ 📄 VisibleBaseClass.java
           ┃                    ┣━ 📄 DiamondLeft.java
           ┃                    ┣━ 📄 DiamondRight.java
           ┃                    ┣━ 📄 EnumFromScopedModule.java
@@ -3682,6 +3683,45 @@ public class InterfaceFactory extends software.amazon.jsii.JsiiObject {
 
 `;
 
+exports[`Generated code for "@scope/jsii-calc-lib": <outDir>/java/src/main/java/software/amazon/jsii/tests/calculator/lib/deprecation_removal/VisibleBaseClass.java 1`] = `
+package software.amazon.jsii.tests.calculator.lib.deprecation_removal;
+
+/**
+ */
+@javax.annotation.Generated(value = "jsii-pacmak")
+@software.amazon.jsii.Stability(software.amazon.jsii.Stability.Level.Deprecated)
+@Deprecated
+@software.amazon.jsii.Jsii(module = software.amazon.jsii.tests.calculator.lib.$Module.class, fqn = "@scope/jsii-calc-lib.deprecationRemoval.VisibleBaseClass")
+public class VisibleBaseClass extends software.amazon.jsii.JsiiObject {
+
+    protected VisibleBaseClass(final software.amazon.jsii.JsiiObjectRef objRef) {
+        super(objRef);
+    }
+
+    protected VisibleBaseClass(final software.amazon.jsii.JsiiObject.InitializationMode initializationMode) {
+        super(initializationMode);
+    }
+
+    /**
+     */
+    @software.amazon.jsii.Stability(software.amazon.jsii.Stability.Level.Deprecated)
+    @Deprecated
+    public VisibleBaseClass() {
+        super(software.amazon.jsii.JsiiObject.InitializationMode.JSII);
+        software.amazon.jsii.JsiiEngine.getInstance().createNewObject(this);
+    }
+
+    /**
+     */
+    @software.amazon.jsii.Stability(software.amazon.jsii.Stability.Level.Deprecated)
+    @Deprecated
+    public @org.jetbrains.annotations.NotNull java.lang.Boolean getPropertyPresent() {
+        return software.amazon.jsii.Kernel.get(this, "propertyPresent", software.amazon.jsii.NativeType.forClass(java.lang.Boolean.class));
+    }
+}
+
+`;
+
 exports[`Generated code for "@scope/jsii-calc-lib": <outDir>/java/src/main/java/software/amazon/jsii/tests/calculator/lib/package-info.java 1`] = `
 /**
  *
@@ -3709,6 +3749,7 @@ exports[`Generated code for "@scope/jsii-calc-lib": <outDir>/java/src/main/resou
 @scope/jsii-calc-lib.StructWithOnlyOptionals=software.amazon.jsii.tests.calculator.lib.StructWithOnlyOptionals
 @scope/jsii-calc-lib.deprecationRemoval.IInterface=software.amazon.jsii.tests.calculator.lib.deprecation_removal.IInterface
 @scope/jsii-calc-lib.deprecationRemoval.InterfaceFactory=software.amazon.jsii.tests.calculator.lib.deprecation_removal.InterfaceFactory
+@scope/jsii-calc-lib.deprecationRemoval.VisibleBaseClass=software.amazon.jsii.tests.calculator.lib.deprecation_removal.VisibleBaseClass
 @scope/jsii-calc-lib.submodule.IReflectable=software.amazon.jsii.tests.calculator.custom_submodule_name.IReflectable
 @scope/jsii-calc-lib.submodule.NestingClass=software.amazon.jsii.tests.calculator.custom_submodule_name.NestingClass
 @scope/jsii-calc-lib.submodule.NestingClass.NestedClass=software.amazon.jsii.tests.calculator.custom_submodule_name.NestingClass$NestedClass
diff --git a/packages/jsii-pacmak/test/generated-code/__snapshots__/target-python.test.js.snap b/packages/jsii-pacmak/test/generated-code/__snapshots__/target-python.test.js.snap
index eb50eebd42..084f31c4ed 100644
--- a/packages/jsii-pacmak/test/generated-code/__snapshots__/target-python.test.js.snap
+++ b/packages/jsii-pacmak/test/generated-code/__snapshots__/target-python.test.js.snap
@@ -2334,9 +2334,33 @@ class InterfaceFactory(
         return typing.cast(IInterface, jsii.sinvoke(cls, "create", []))
 
 
+class VisibleBaseClass(
+    metaclass=jsii.JSIIMeta,
+    jsii_type="@scope/jsii-calc-lib.deprecationRemoval.VisibleBaseClass",
+):
+    '''
+    :stability: deprecated
+    '''
+
+    def __init__(self) -> None:
+        '''
+        :stability: deprecated
+        '''
+        jsii.create(self.__class__, self, [])
+
+    @builtins.property
+    @jsii.member(jsii_name="propertyPresent")
+    def property_present(self) -> builtins.bool:
+        '''
+        :stability: deprecated
+        '''
+        return typing.cast(builtins.bool, jsii.get(self, "propertyPresent"))
+
+
 __all__ = [
     "IInterface",
     "InterfaceFactory",
+    "VisibleBaseClass",
 ]
 
 publication.publish()
diff --git a/packages/jsii-reflect/test/__snapshots__/jsii-tree.test.js.snap b/packages/jsii-reflect/test/__snapshots__/jsii-tree.test.js.snap
index 835e0e619b..4d3be9416d 100644
--- a/packages/jsii-reflect/test/__snapshots__/jsii-tree.test.js.snap
+++ b/packages/jsii-reflect/test/__snapshots__/jsii-tree.test.js.snap
@@ -3511,6 +3511,12 @@ exports[`jsii-tree --all 1`] = `
    │ │   │   └─┬ static create() method (deprecated)
    │ │   │     ├── static
    │ │   │     └── returns: @scope/jsii-calc-lib.deprecationRemoval.IInterface
+   │ │   ├─┬ class VisibleBaseClass (deprecated)
+   │ │   │ └─┬ members
+   │ │   │   ├── <initializer>() initializer (deprecated)
+   │ │   │   └─┬ propertyPresent property (deprecated)
+   │ │   │     ├── immutable
+   │ │   │     └── type: boolean
    │ │   └─┬ interface IInterface (deprecated)
    │ │     └─┬ members
    │ │       └─┬ method() method (deprecated)
@@ -4184,6 +4190,7 @@ exports[`jsii-tree --inheritance 1`] = `
    │ ├─┬ deprecationRemoval
    │ │ └─┬ types
    │ │   ├── class InterfaceFactory
+   │ │   ├── class VisibleBaseClass
    │ │   └── interface IInterface
    │ └─┬ submodule
    │   └─┬ types
@@ -5808,6 +5815,10 @@ exports[`jsii-tree --members 1`] = `
    │ │   ├─┬ class InterfaceFactory
    │ │   │ └─┬ members
    │ │   │   └── static create() method
+   │ │   ├─┬ class VisibleBaseClass
+   │ │   │ └─┬ members
+   │ │   │   ├── <initializer>() initializer
+   │ │   │   └── propertyPresent property
    │ │   └─┬ interface IInterface
    │ │     └─┬ members
    │ │       └── method() method
@@ -6354,6 +6365,7 @@ exports[`jsii-tree --types 1`] = `
    │ ├─┬ deprecationRemoval
    │ │ └─┬ types
    │ │   ├── class InterfaceFactory
+   │ │   ├── class VisibleBaseClass
    │ │   └── interface IInterface
    │ └─┬ submodule
    │   └─┬ types
diff --git a/packages/jsii-reflect/test/__snapshots__/tree.test.js.snap b/packages/jsii-reflect/test/__snapshots__/tree.test.js.snap
index 4e12655772..0ac611c611 100644
--- a/packages/jsii-reflect/test/__snapshots__/tree.test.js.snap
+++ b/packages/jsii-reflect/test/__snapshots__/tree.test.js.snap
@@ -3688,6 +3688,12 @@ exports[`showAll 1`] = `
    │ │   │   └─┬ static create() method
    │ │   │     ├── static
    │ │   │     └── returns: @scope/jsii-calc-lib.deprecationRemoval.IInterface
+   │ │   ├─┬ class VisibleBaseClass
+   │ │   │ └─┬ members
+   │ │   │   ├── <initializer>() initializer
+   │ │   │   └─┬ propertyPresent property
+   │ │   │     ├── immutable
+   │ │   │     └── type: boolean
    │ │   └─┬ interface IInterface
    │ │     └─┬ members
    │ │       └─┬ method() method
@@ -4321,6 +4327,7 @@ exports[`types 1`] = `
    │ ├─┬ deprecationRemoval
    │ │ └─┬ types
    │ │   ├── class InterfaceFactory
+   │ │   ├── class VisibleBaseClass
    │ │   └── interface IInterface
    │ └─┬ submodule
    │   └─┬ types
diff --git a/packages/jsii-reflect/test/__snapshots__/type-system.test.js.snap b/packages/jsii-reflect/test/__snapshots__/type-system.test.js.snap
index 0ad963b291..65e75d7eb7 100644
--- a/packages/jsii-reflect/test/__snapshots__/type-system.test.js.snap
+++ b/packages/jsii-reflect/test/__snapshots__/type-system.test.js.snap
@@ -21,6 +21,7 @@ exports[`TypeSystem.classes lists all the classes in the typesystem 1`] = `
   "@scope/jsii-calc-lib.NumericValue",
   "@scope/jsii-calc-lib.Operation",
   "@scope/jsii-calc-lib.deprecationRemoval.InterfaceFactory",
+  "@scope/jsii-calc-lib.deprecationRemoval.VisibleBaseClass",
   "@scope/jsii-calc-lib.submodule.NestingClass",
   "@scope/jsii-calc-lib.submodule.NestingClass.NestedClass",
   "@scope/jsii-calc-lib.submodule.Reflector",
diff --git a/packages/jsii-rosetta/test/jsii/assemblies.test.ts b/packages/jsii-rosetta/test/jsii/assemblies.test.ts
index e260b482b6..e0f4b713d8 100644
--- a/packages/jsii-rosetta/test/jsii/assemblies.test.ts
+++ b/packages/jsii-rosetta/test/jsii/assemblies.test.ts
@@ -1,6 +1,6 @@
 import * as spec from '@jsii/spec';
 import { promises as fs } from 'fs';
-import * as mockfs from 'mock-fs';
+import * as os from 'os';
 import * as path from 'path';
 
 import { allTypeScriptSnippets } from '../../lib/jsii/assemblies';
@@ -199,11 +199,11 @@ test('Fixture allows use of import statements', async () => {
 });
 
 test('Backwards compatibility with literate integ tests', async () => {
-  mockfs({
-    '/package/test/integ.example.lit.ts': '# Some literate source file',
-  });
-
+  const directory = await fs.mkdtemp(path.join(os.tmpdir(), 'jsii-rosetta-tests-'));
   try {
+    await fs.mkdir(path.join(directory, 'test'));
+    await fs.writeFile(path.join(directory, 'test', 'integ.example.lit.ts'), '# Some literate source file');
+
     const snippets = Array.from(
       await allTypeScriptSnippets([
         {
@@ -218,18 +218,16 @@ test('Backwards compatibility with literate integ tests', async () => {
               ].join('\n'),
             },
           }),
-          directory: '/package',
+          directory,
         },
       ]),
     );
 
     expect(snippets[0].visibleSource).toEqual('someExample();');
     expect(snippets[0].completeSource).toEqual('# Some literate source file');
-    expect(snippets[0]?.parameters?.[SnippetParameters.$COMPILATION_DIRECTORY]).toEqual(
-      path.normalize('/package/test'),
-    );
+    expect(snippets[0]?.parameters?.[SnippetParameters.$COMPILATION_DIRECTORY]).toEqual(path.join(directory, 'test'));
   } finally {
-    mockfs.restore();
+    await fs.rm(directory, { force: true, recursive: true });
   }
 });
 
diff --git a/tsconfig-base.json b/tsconfig-base.json
index e8d41fbe6f..d1dab8556b 100644
--- a/tsconfig-base.json
+++ b/tsconfig-base.json
@@ -2,6 +2,7 @@
   "compilerOptions": {
     "target": "ES2020",                    /* Specify ECMAScript target version: 'ES3' (default), 'ES5', 'ES2015', 'ES2016', 'ES2017', or 'ESNEXT'. */
     "module": "commonjs",                  /* Specify module code generation: 'commonjs', 'amd', 'system', 'umd', 'es2015', or 'ESNext'. */
+    "moduleResolution": "Node",            /* Specify module resolution strategy: 'node' (Node.js) or 'classic' (TypeScript pre-1.6). */
     "lib": ["es2020", "es2021.WeakRef"],   /* Specify library files to be included in the compilation:  */
     "strict": true,                        /* Enable all strict type-checking options. */
     "strictPropertyInitialization": true,  /* Require all properties be initialized in the constructor. */