TypeScript client

import {
  AdmissionStatus,
  AuthenticationScheme,
  MessageKind,
  QueueState,
  WovenClient,
} from "@signalweave/woven-client";

type HostConnectionDescriptor = {
  token: string;
  namespaceId: string;
  sessionId: string;
  webTransport: {
    url: string;
    certificateSha256?: string;
  };
  spaces: Array<
    | {
        kind: "logical";
        spaceId: "1" | "2";
        epoch: "1";
        channelIds: ["1", "4"];
      }
    | {
        kind: "spatialGrid3D";
        slug: string;
        displayName: string;
        spaceId: string;
        epoch: "1";
        channelIds: ["1", "4"];
        metersPerUnit: number;
        cellSize: number;
        interestRadius: number;
        exactDistance: boolean;
        bounds: {
          min: { x: number; y: number; z: number };
          max: { x: number; y: number; z: number };
        };
      }
  >;
};

const MAX_U64 = 18_446_744_073_709_551_615n;

function scopeId(value: string, name: string): bigint {
  if (!/^[1-9][0-9]*$/.test(value)) throw new Error(`invalid ${name}`);
  const parsed = BigInt(value);
  if (parsed > MAX_U64) throw new Error(`${name} exceeds u64`);
  return parsed;
}

function sha256Bytes(hex: string): Uint8Array {
  if (!/^[0-9a-f]{64}$/.test(hex)) {
    throw new Error("certificateSha256 must be 64 lowercase hex characters");
  }
  return Uint8Array.from(
    { length: 32 },
    (_, index) => Number.parseInt(hex.slice(index * 2, index * 2 + 2), 16),
  );
}

const descriptor: HostConnectionDescriptor = await connectionResponse.json();
const certificateSha256 = descriptor.webTransport.certificateSha256;
const client = await WovenClient.connect({
  url: descriptor.webTransport.url,
  token: descriptor.token,
  authenticationScheme: AuthenticationScheme.Bearer,
  webTransportOptions: certificateSha256
    ? {
        serverCertificateHashes: [
          { algorithm: "sha-256", value: sha256Bytes(certificateSha256) },
        ],
      }
    : undefined,
});

const namespaceId = scopeId(descriptor.namespaceId, "namespaceId");
const sessionId = scopeId(descriptor.sessionId, "sessionId");

const cancellation = new AbortController();
// Call cancellation.abort() from your application's explicit stop control.
const outcome = await client.admitWithCancellation(
  namespaceId,
  sessionId,
  crypto.randomUUID(),
  60_000,
  cancellation.signal,
);

const admitted =
  outcome.kind === "admission"
    ? outcome.result.status === AdmissionStatus.Admitted
    : outcome.update.state === QueueState.Admitted;
if (!admitted) {
  client.close(1, "not admitted");
  throw new Error("managed admission did not admit this connection");
}

const space = descriptor.spaces[0];
if (!space) throw new Error("descriptor has no spaces");
const channel = "1";
if (!space.channelIds.includes(channel)) {
  throw new Error("channel 1 is not allowed for this space");
}

const spaceId = scopeId(space.spaceId, "spaceId");
const spaceEpoch = scopeId(space.epoch, "spaceEpoch");
const channelId = scopeId(channel, "channelId");

// Managed admission has already returned Admitted before this subscription.
await client.subscribeSpace(namespaceId, sessionId, spaceId, spaceEpoch, channelId);

// Treat SubscriptionRejected as fatal. Publish only after SubscriptionAccepted
// is followed by EntityEntered with the server-assigned entity ID.
const subscriptionReply = await client.recvTimeout(2_000);
if (subscriptionReply?.messageKind !== MessageKind.SubscriptionAccepted) {
  throw new Error("subscription was not accepted");
}
const entityAssignment = await client.recvTimeout(2_000);
if (entityAssignment?.messageKind !== MessageKind.EntityEntered) {
  throw new Error("server did not assign an entity");
}
const entityId = entityAssignment.entityId;
if (entityId === null) throw new Error("entity assignment omitted its entity ID");

await client.publishEvent(
  namespaceId,
  sessionId,
  spaceId,
  spaceEpoch,
  channelId,
  entityId,
  1n, // sender sequence; increment for each event in this scope
  1n, // application-defined payload type ID
  new TextEncoder().encode("hello from Woven Host"),
);

client.close();

// After managed admission returns Admitted; no space subscription is needed.
await client.logger.info("Scene loaded");
await client.logger.warn("Optional asset unavailable");
await client.logger.error("Failed to save progress");
await client.log("Info-level alias");

// Await sequentially: these share the existing ordered control stream.
// Sending is not database acknowledgement; keep receiving server rejections.