osra 0.6.5 → 0.6.7

package/build/revivables/identity.d.ts

@@ -9,24 +9,26 @@ export type Messages = {
 };
 export declare const Messages: Messages;
 declare const IDENTITY_MARKER: unique symbol;
-type IdentityWrapper<T = unknown> = {
+/** Phantom shape. A tracked value carries no marker of its own, the mark lives in a WeakMap, so
+ *  this is what `isType` declares instead: matching it at the type level would widen `Capable` to
+ *  every object, and nothing a user writes structurally matches this. */
+type IdentityMarked = {
     readonly [IDENTITY_MARKER]: true;
-    readonly value: T;
 };
 export type BoxedIdentity<T extends Capable = Capable> = BoxBaseType<typeof type> & {
     id: string;
     inner?: Capable;
     [UnderlyingType]: T;
 };
-/** Wrap a value so osra preserves reference identity across the RPC
- *  boundary. Idempotent; primitives pass through unchanged. Lies at the
- *  type level - runtime value is an IdentityWrapper<T> typed as T. */
+/** Mark a value so osra preserves its reference identity across the boundary. The peer's revived
+ *  value stands for this one, and handing it back - to you, or onward to a further context and back
+ *  again - resolves to this very reference. The mark sticks to the value, so only the side that
+ *  owns it has to opt in. Idempotent, and primitives pass through unchanged. */
 export declare const identity: <T>(value: T) => T;
-export declare const isType: (value: unknown) => value is IdentityWrapper;
-export declare const box: <T extends Capable, TContext extends RevivableContext>(wrapper: IdentityWrapper<T>, context: TContext) => BoxedIdentity<T>;
-/** Identity-box a referenceable value with a caller-supplied inner box,
- *  bypassing the recursive-box step. Used by revivables (symbol with
- *  description=undefined) where recursing back through their own box
+export declare const isType: (value: unknown) => value is IdentityMarked;
+export declare const box: <T extends Capable, TContext extends RevivableContext>(value: T, context: TContext) => BoxedIdentity<T>;
+/** Identity-box a referenceable value with a caller-supplied inner box, bypassing the walker. Used
+ *  by revivables (symbol with description=undefined) where recursing back through their own box
  *  would loop into this module again. */
 export declare const boxByReference: <T extends WeakKey, TContext extends RevivableContext>(value: T, innerBox: Capable, context: TContext) => BoxedIdentity;
 export declare const revive: <T extends BoxedIdentity, TContext extends RevivableContext>(value: T, context: TContext) => T[UnderlyingType];

package/build/revivables/index.d.ts

@@ -71,4 +71,11 @@ export declare const defaultRevivableModules: readonly [typeof transfer, typeof
 export type DefaultRevivableModules = typeof defaultRevivableModules;
 export type DefaultRevivableModule = DefaultRevivableModules[number];
 export declare const recursiveBox: <T extends Capable, TModules extends readonly RevivableModule[]>(value: T, context: RevivableContext<TModules>) => DeepReplaceWithBox<T, TModules[number]>;
+/** Box a value your own module claimed in place: every other module gets its turn and children are
+ *  walked as usual, but `claimedBy` is skipped, and the cycle guard the caller's `recursiveBox`
+ *  frame already holds for this value is not re-entered.
+ *  A module needs this when its `isType` matches a bare value rather than a wrapper around one, the
+ *  way `identity()` marks a reference in place: `recursiveBox` on that same value would come
+ *  straight back to the module, and the guard would report it as a cycle. */
+export declare const boxClaimedValue: <T extends Capable, TModules extends readonly RevivableModule[]>(value: T, context: RevivableContext<TModules>, claimedBy: string) => DeepReplaceWithBox<T, TModules[number]>;
 export declare const recursiveRevive: <T extends Capable, TModules extends readonly RevivableModule[]>(value: T, context: RevivableContext<TModules>) => DeepReplaceWithRevive<T, TModules[number]>;

package/build/revivables/transfer.d.ts

@@ -16,6 +16,19 @@ export type BoxedTransfer<T extends Capable = Capable> = BoxBaseType<typeof type
  *  copy when the platform/transport can't transfer the given type. Lies at
  *  the type level - runtime value is a TransferWrapper<T> typed as T. */
 export declare const transfer: <T>(value: T) => T;
+/** Whether boxing is happening inside a transfer() wrapper's extent. Streams read
+ *  this at box time so transfer(stream) propagates move semantics to their chunks. */
+export declare const isInTransfer: () => boolean;
+/** Internal chunk marker: unlike the public transfer(), wraps containers too, so
+ *  transferables nested anywhere inside a chunk move. Not part of the public API. */
+export declare const forceTransfer: <T>(value: T) => T;
+/** Runs fn with the ambient transfer extent suspended. Boxing at independent walk
+ *  entry points (protocol ports, revived-function calls) can fire synchronously
+ *  inside someone else's transfer() extent - an EventPort.start() flush during
+ *  boxing, or user code (a getter) calling a revived function mid-walk. Those
+ *  values are not part of the wrapper's graph, so their move semantics must come
+ *  from a wrapper in their own data, never from the ambient counter. */
+export declare const outsideTransfer: <T>(fn: () => T) => T;
 export declare const isType: (value: unknown) => value is TransferWrapper;
 export declare const box: <T extends Capable, TContext extends RevivableContext>(wrapper: TransferWrapper<T>, context: TContext) => BoxedTransfer<T>;
 export declare const revive: <T extends BoxedTransfer, TContext extends RevivableContext>(value: T, context: TContext) => T[UnderlyingType];

package/build/revivables/writable-stream.d.ts

@@ -21,6 +21,7 @@ export type WriteAck = {
 export type Msg = WriteContext | WriteAck;
 export type BoxedWritableStream<T extends WritableStream = WritableStream> = BoxBaseType<typeof type> & {
     port: BoxedMessagePort<Msg>;
+    transferChunks?: true;
 } & {
     [UnderlyingType]: T;
 };

package/build/types.d.ts

@@ -9,9 +9,7 @@ export type Uuid = `${string}-${string}-${string}-${string}-${string}`;
 export type Jsonable = boolean | null | number | string | {
     [key: string]: Jsonable;
 } | ReadonlyArray<Jsonable>;
-export type Structurable = Jsonable
-/** not really structureable but here for convenience */
- | void | undefined | bigint | Date | RegExp | Blob | File | FileList | ArrayBuffer | ArrayBufferView | ImageBitmap | ImageData | {
+export type Structurable = Jsonable | void | undefined | bigint | Date | RegExp | Blob | File | FileList | ArrayBuffer | ArrayBufferView | ImageBitmap | ImageData | {
     [key: string]: Structurable;
 } | ReadonlyArray<Structurable> | Map<Structurable, Structurable> | Set<Structurable>;
 /** lib.dom declares some `Transferable` members as EMPTY interfaces

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "osra",
-  "version": "0.6.5",
+  "version": "0.6.7",
   "description": "Easy communication between workers",
   "homepage": "https://github.com/Banou26/osra#readme",
   "bugs": {
@@ -57,19 +57,19 @@
     "docs-dev": "npm run dev -w docs",
     "docs-build": "npm run build -w docs",
     "docs-preview": "npm run preview -w docs",
+    "docs-gen-reference": "npm run gen:reference -w docs",
+    "docs-check-links": "npm run check-links -w docs",
     "docs-check-twoslash": "npm run check-twoslash -w docs"
   },
-  "dependencies": {
-    "@types/webextension-polyfill": "^0.12.4"
-  },
   "devDependencies": {
     "@istanbuljs/nyc-config-typescript": "^1.0.2",
     "@playwright/test": "1.58.2",
     "@types/chai": "^5.2.3",
     "@types/chai-as-promised": "^8.0.2",
-    "@types/chrome": "^0.1.27",
+    "@types/chrome": "^0.1.43",
     "@types/firefox-webext-browser": "^143.0.0",
     "@types/node": "^25.0.2",
+    "@types/webextension-polyfill": "^0.12.5",
     "chai": "^5.3.3",
     "chai-as-promised": "^8.0.1",
     "concurrently": "^9.1.0",