Hide types of internal symbols

Author: W4G1

scripts/build.ts

@@ -116,6 +116,7 @@ const compilerOptions: ts.CompilerOptions = {
   lib: ["lib.esnext.d.ts", "lib.dom.d.ts", "lib.webworker.d.ts"],
   skipLibCheck: true,
   allowImportingTsExtensions: true,
+  stripInternal: true,
 };
 
 const host = ts.createCompilerHost(compilerOptions);

src/lib/json_buffer.ts

@@ -7,7 +7,7 @@ import {
 
 export type Proxyable = Record<string | symbol, any> | any[];
 
-const CONSOLE_VIEW = Symbol.for("SharedJsonBuffer.consoleView");
+const CONSOLE_VIEW = Symbol("SharedJsonBuffer.consoleView");
 
 const OFFSET_FREE_PTR = 0;
 const OFFSET_ROOT = 8; // 8-byte aligned
@@ -1332,6 +1332,9 @@ class SharedJsonBufferImpl<T extends Proxyable> extends Serializable {
     }
   }
 
+  /**
+   * @internal
+   */
   [toSerialized]() {
     return {
       value: this.buffer,
@@ -1340,6 +1343,9 @@ class SharedJsonBufferImpl<T extends Proxyable> extends Serializable {
     };
   }
 
+  /**
+   * @internal
+   */
   static override [toDeserialized](
     data: ReturnType<
       SharedJsonBufferImpl<any>[typeof toSerialized]

src/lib/lib.ts

@@ -27,7 +27,7 @@ function getPool(): WorkerPool {
  * A branded type that ensures the array has been explicitly marked
  * by the move() function.
  */
-const moveTag = Symbol.for("Thread.move");
+const moveTag = Symbol("Thread.move");
 export type MovedData<T extends any[]> = T & { readonly [moveTag]: true };
 
 export function move<Args extends any[]>(...args: Args): MovedData<Args> {

src/lib/shared.ts

@@ -1,7 +1,7 @@
 import { Envelope } from "./types.ts";
 
-export const toSerialized = Symbol.for("Thread.Serialize");
-export const toDeserialized = Symbol.for("Thread.Deserialize");
+export const toSerialized = Symbol("Thread.Serialize");
+export const toDeserialized = Symbol("Thread.Deserialize");
 
 export const enum PayloadType {
   RAW = 0, // User data (Numbers, Strings, Plain Objects)

src/lib/sync/condvar.ts

@@ -70,13 +70,19 @@ export class Condvar extends Serializable {
     Atomics.notify(this.#atomic, 0, Infinity);
   }
 
+  /**
+   * @internal
+   */
   [toSerialized]() {
     return {
       value: this.#atomic.buffer,
       transfer: [],
     };
   }
 
+  /**
+   * @internal
+   */
   static override [toDeserialized](
     obj: ReturnType<Condvar[typeof toSerialized]>["value"],
   ) {

src/lib/sync/mpmc.ts

@@ -37,6 +37,9 @@ class ChannelInternals<T> extends Serializable {
     super();
   }
 
+  /**
+   * @internal
+   */
   [toSerialized]() {
     const itemsSer = serialize(this.items);
     const sendLockSer = serialize(this.sendLock);
@@ -205,6 +208,9 @@ export class Sender<T> extends Serializable implements Disposable {
     this.disposed = true;
   }
 
+  /**
+   * @internal
+   */
   [toSerialized]() {
     if (this.disposed) {
       throw new Error("Cannot move a disposed Sender");
@@ -215,6 +221,9 @@ export class Sender<T> extends Serializable implements Disposable {
     return serialize(this.internals);
   }
 
+  /**
+   * @internal
+   */
   static override [toDeserialized](
     obj: ReturnType<Sender<any>[typeof toSerialized]>["value"],
   ) {
@@ -359,6 +368,9 @@ export class Receiver<T> extends Serializable implements Disposable {
     }
   }
 
+  /**
+   * @internal
+   */
   [toSerialized]() {
     if (this.disposed) {
       throw new Error("Cannot move a disposed Receiver");
@@ -371,6 +383,9 @@ export class Receiver<T> extends Serializable implements Disposable {
     return serialize(this.internals);
   }
 
+  /**
+   * @internal
+   */
   static override [toDeserialized](
     obj: ReturnType<Receiver<any>[typeof toSerialized]>["value"],
   ) {

src/lib/sync/mutex.ts

@@ -25,13 +25,11 @@ export class MutexGuard<T extends SharedMemoryView | void>
   implements Disposable {
   #data: T;
   #released = false;
-  [INTERNAL_MUTEX_CONTROLLER]!: MutexController;
-
   /**
    * @internal
-   * We pass the controller here, but we don't store it in a public field.
-   * We attach it using defineProperty.
    */
+  [INTERNAL_MUTEX_CONTROLLER]!: MutexController;
+
   constructor(data: T, controller: MutexController) {
     this.#data = data;
     this.#released = false;
@@ -136,6 +134,9 @@ export class Mutex<T extends SharedMemoryView | void = void>
     return new MutexGuard(this.#data, this.#createController());
   }
 
+  /**
+   * @internal
+   */
   [toSerialized]() {
     let serializedData;
     let transfer: Transferable[] = [];
@@ -155,6 +156,9 @@ export class Mutex<T extends SharedMemoryView | void = void>
     };
   }
 
+  /**
+   * @internal
+   */
   static override [toDeserialized](
     obj: ReturnType<Mutex<any>[typeof toSerialized]>["value"],
   ) {

src/lib/sync/rwlock.ts

@@ -29,6 +29,9 @@ export class RwLockReadGuard<T extends SharedMemoryView | void>
   implements Disposable {
   #data: T;
   #released = false;
+  /**
+   * @internal
+   */
   [INTERNAL_RWLOCK_CONTROLLER]!: RwLockController;
 
   constructor(data: T, controller: RwLockController) {
@@ -248,6 +251,9 @@ export class RwLock<T extends SharedMemoryView | void = void>
     }
   }
 
+  /**
+   * @internal
+   */
   [toSerialized]() {
     let serializedData;
     let transfer: Transferable[] = [];
@@ -267,6 +273,9 @@ export class RwLock<T extends SharedMemoryView | void = void>
     };
   }
 
+  /**
+   * @internal
+   */
   static override [toDeserialized](
     obj: ReturnType<RwLock<any>[typeof toSerialized]>["value"],
   ) {

src/lib/sync/semaphore.ts

@@ -65,6 +65,9 @@ export class Semaphore extends Serializable {
    * [1]: waiters (The number of threads currently waiting)
    */
   #state: Int32Array<SharedArrayBuffer>;
+  /**
+   * @internal
+   */
   [INTERNAL_SEMAPHORE_CONTROLLER]!: SemaphoreController;
 
   constructor(initialCount: number, _buffer?: SharedArrayBuffer) {
@@ -175,13 +178,19 @@ export class Semaphore extends Serializable {
     }
   }
 
+  /**
+   * @internal
+   */
   [toSerialized]() {
     return {
       value: this.#state.buffer,
       transfer: [],
     };
   }
 
+  /**
+   * @internal
+   */
   static override [toDeserialized](buffer: SharedArrayBuffer) {
     return new Semaphore(0, buffer);
   }