@almadar/shell-runtime 0.1.0 → 1.0.0

package/dist/chunk-ZAQSS47X.js

@@ -1,157 +0,0 @@
-import { base64Standard, isOAuthReason, isOAuthCode } from './chunk-YO4LWS3I.js';
-import { isJsonObject } from '@almadar/core';
-
-var PENDING_GRANT_TTL_MS = 10 * 60 * 1e3;
-var MOCK_PENDING_TTL_MS = Number.MAX_SAFE_INTEGER;
-var PROVIDERS = ["google", "github", "auth0"];
-var OAuthEffectFailure = class extends Error {
-  constructor(payload) {
-    super(payload.error);
-    this.payload = payload;
-  }
-  payload;
-};
-function parsed(text) {
-  return JSON.parse(text);
-}
-function objectOf(value, what) {
-  if (value === void 0 || !isJsonObject(value)) throw new Error(`${what} is malformed`);
-  return value;
-}
-function failureOf(kernel, reason) {
-  if (kernel.oauthFailure === void 0) throw new Error("this kernel build has no OAuth failure messages");
-  const payload = objectOf(parsed(kernel.oauthFailure(reason)), "the oauth failure");
-  const { error, code } = payload;
-  if (typeof error !== "string" || !isOAuthCode(code)) throw new Error("the oauth failure is malformed");
-  return new OAuthEffectFailure({ error, code, reason });
-}
-async function ask(ports, kernel, request, principal) {
-  if (ports.oauth === void 0) throw failureOf(kernel, "store-unavailable");
-  try {
-    const reply = await ports.oauth.answer(request, principal);
-    if (!isReplyOf(request, reply)) throw new Error("wrong reply");
-    return reply;
-  } catch {
-    throw failureOf(kernel, "store-unavailable");
-  }
-}
-function isReplyOf(request, reply) {
-  switch (request.ask) {
-    case "pendingPut":
-    case "subjectRemember":
-    case "subjectForget":
-    case "metadataPut":
-      return reply.reply === "done";
-    case "pendingTake":
-      return reply.reply === "taken";
-    case "connectionAvailable":
-      return reply.reply === "flag";
-    case "connectionSave":
-    case "connectionStatus":
-    case "connectionRemove":
-      return reply.reply === "row";
-    case "subjectLookup":
-      return reply.reply === "subject";
-    case "metadataGet":
-      return reply.reply === "metadata";
-    case "clock":
-      return reply.reply === "millis";
-    case "mockTokenPut":
-      return reply.reply === "done";
-    case "mockTokenRefresh":
-    case "mockTokenRevoke":
-      return reply.reply === "flag";
-    case "mockTokenCheck":
-      return reply.reply === "mockToken";
-    case "consent":
-      return reply.reply === "code";
-  }
-}
-async function oauthAuthorizePayload(ports, client, options, principal, key) {
-  if (key !== void 0 && (typeof key !== "string" || key === "")) {
-    throw new Error(`call key must evaluate to a non-empty string, got ${String(key)}`);
-  }
-  const echoed = typeof key === "string" ? key : null;
-  const kernel = await ports.kernel();
-  if (kernel.oauthAuthorizePlan === void 0 || kernel.oauthAuthorizeBuild === void 0) {
-    throw new Error("oauth-authorize: this kernel build cannot run it");
-  }
-  const planned = objectOf(parsed(kernel.oauthAuthorizePlan(JSON.stringify(client ?? null), JSON.stringify(options ?? null))), "the authorize plan");
-  if (planned.mode === "mock") {
-    if (kernel.oauthAuthorizeMockBuild === void 0) throw new Error("oauth-authorize: this kernel build cannot run it");
-    const mock = objectOf(parsed(kernel.oauthAuthorizeMockBuild(JSON.stringify(planned.plan ?? null), base64Standard(ports.random(16)))), "the authorization");
-    return keepGrant(ports, kernel, mock, MOCK_PENDING_TTL_MS, principal, echoed, false);
-  }
-  const slot = objectOf(planned.clientId, "the client id slot");
-  if (typeof slot.name !== "string") throw new Error("the client id slot is malformed");
-  let owner;
-  if (slot.scope === "user") {
-    if (principal === void 0) throw failureOf(kernel, "not-signed-in");
-    owner = principal;
-  }
-  const clientId = await ports.secrets.get(slot.name, owner);
-  if (clientId === void 0) throw failureOf(kernel, "unconfigured-client");
-  let metadata = planned.metadata ?? null;
-  if (typeof planned.issuer === "string") {
-    const reply = await ask(ports, kernel, { ask: "metadataGet", issuer: planned.issuer }, principal);
-    metadata = reply.reply === "metadata" ? reply.metadata : null;
-  }
-  if (metadata === null) throw failureOf(kernel, "metadata-invalid");
-  const state = ports.random(32);
-  const verifier = ports.random(32);
-  const built = objectOf(
-    parsed(kernel.oauthAuthorizeBuild(JSON.stringify(planned.plan ?? null), clientId, JSON.stringify(metadata), base64Standard(state), base64Standard(verifier))),
-    "the authorization"
-  );
-  if (typeof built.refused === "string") throw new Error(built.refused);
-  if (built.failure !== void 0) {
-    const failure = objectOf(built.failure, "the failure");
-    const reason = failure.reason;
-    if (!isOAuthReason(reason)) throw new Error("the oauth failure is malformed");
-    throw failureOf(kernel, reason);
-  }
-  return keepGrant(ports, kernel, objectOf(built.ok, "the authorization"), PENDING_GRANT_TTL_MS, principal, echoed, true);
-}
-async function keepGrant(ports, kernel, ok, ttlMs, principal, key, consent) {
-  const grant = objectOf(ok.grant, "the pending grant");
-  if (typeof ok.authUrl !== "string" || typeof ok.state !== "string") throw new Error("the authorization is malformed");
-  const scopes = Array.isArray(grant.scopes) ? grant.scopes.flatMap((scope) => typeof scope === "string" ? [scope] : []) : [];
-  await ask(
-    ports,
-    kernel,
-    {
-      ask: "pendingPut",
-      state: ok.state,
-      ttlMs,
-      grant: {
-        provider: String(grant.provider),
-        redirectUri: String(grant.redirectUri),
-        verifier: String(grant.verifier),
-        subject: typeof grant.subject === "string" ? grant.subject : null,
-        scopes
-      }
-    },
-    principal
-  );
-  let code = "";
-  if (consent) {
-    const reply = await ask(ports, kernel, { ask: "consent", authUrl: ok.authUrl, state: ok.state, redirectUri: String(grant.redirectUri) }, principal);
-    code = reply.reply === "code" ? reply.code ?? "" : "";
-  }
-  return { authUrl: ok.authUrl, state: ok.state, code, key };
-}
-async function oauthConnectionPayload(ports, head, provider, principal) {
-  const word = PROVIDERS.find((known) => known === provider);
-  if (word === void 0) {
-    throw new Error(typeof provider === "string" ? `${head}: provider must be google, github or auth0, not \`${provider}\`` : `${head}: provider must be a provider word`);
-  }
-  const kernel = await ports.kernel();
-  const available = await ask(ports, kernel, { ask: "connectionAvailable" }, principal);
-  if (available.reply !== "flag" || !available.value) throw failureOf(kernel, "store-unavailable");
-  if (principal === void 0 || principal === "") throw failureOf(kernel, "not-signed-in");
-  const reply = await ask(ports, kernel, head === "oauth-connection-status" ? { ask: "connectionStatus", provider: word } : { ask: "connectionRemove", provider: word }, principal);
-  if (reply.reply !== "row") throw failureOf(kernel, "store-unavailable");
-  return reply.row;
-}
-
-export { OAuthEffectFailure, oauthAuthorizePayload, oauthConnectionPayload };

package/dist/chunk-ZCQUUJIF.js

@@ -1,129 +0,0 @@
-import { detectLayoutStrategy } from './chunk-EV56K4GB.js';
-import { applyEventWiring } from './chunk-MHYSHSRG.js';
-
-// src/runtime/effects/composition/compose-behaviors.ts
-function isSchema(input) {
-  return "orbitals" in input && Array.isArray(input.orbitals);
-}
-function asDefinitions(inputs) {
-  return inputs.flatMap(
-    (input) => isSchema(input) ? input.orbitals : [input]
-  );
-}
-function mergeLedgers(inputs) {
-  const merged = /* @__PURE__ */ new Map();
-  let sawLedger = false;
-  for (const input of inputs) {
-    if (!isSchema(input) || input.ledger === void 0) continue;
-    sawLedger = true;
-    for (const [id, entry] of Object.entries(input.ledger.entries)) {
-      if (!merged.has(id)) merged.set(id, entry);
-    }
-  }
-  if (!sawLedger) return void 0;
-  const entries = {};
-  for (const [id, entry] of [...merged.entries()].sort(
-    ([a], [b]) => a < b ? -1 : a > b ? 1 : 0
-  )) {
-    entries[id] = entry;
-  }
-  return { schemaVersion: 1, entries };
-}
-function mergeSchemaVersions(inputs) {
-  let max;
-  for (const input of inputs) {
-    if (!isSchema(input) || input.schemaVersion === void 0) continue;
-    max = max === void 0 ? input.schemaVersion : Math.max(max, input.schemaVersion);
-  }
-  return max;
-}
-function toKebabCase(name) {
-  return name.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[\s_]+/g, "-").toLowerCase();
-}
-function generatePages(orbitals, strategy) {
-  switch (strategy) {
-    case "single": {
-      const orbital = orbitals[0];
-      const name = orbital?.name ?? "Main";
-      return [
-        {
-          name: `${name}Page`,
-          path: "/",
-          isInitial: true,
-          primaryEntity: getEntityName(orbital)
-        }
-      ];
-    }
-    case "dashboard": {
-      return [
-        {
-          name: "DashboardPage",
-          path: "/",
-          viewType: "dashboard",
-          isInitial: true
-        }
-      ];
-    }
-    case "sidebar":
-    case "tabs":
-    case "wizard-flow": {
-      return orbitals.map((orbital, index) => ({
-        name: `${orbital.name}Page`,
-        path: index === 0 ? "/" : `/${toKebabCase(orbital.name)}`,
-        isInitial: index === 0,
-        primaryEntity: getEntityName(orbital)
-      }));
-    }
-  }
-}
-function getEntityName(orbital) {
-  if (!orbital) return void 0;
-  const entity = orbital.entity;
-  if (typeof entity === "string") {
-    return entity.replace(".entity", "");
-  }
-  return entity.name;
-}
-function composeBehaviors(input) {
-  const {
-    appName,
-    orbitals: rawInputs,
-    layoutStrategy: strategyInput,
-    eventWiring
-  } = input;
-  const rawOrbitals = asDefinitions(rawInputs);
-  const wiredOrbitals = eventWiring && eventWiring.length > 0 ? applyEventWiring(rawOrbitals, eventWiring) : rawOrbitals;
-  const strategy = !strategyInput || strategyInput === "auto" ? detectLayoutStrategy(wiredOrbitals, eventWiring) : strategyInput;
-  const pages = generatePages(wiredOrbitals, strategy);
-  const orbitalsWithPages = wiredOrbitals.map((orbital, index) => {
-    if (orbital.pages && orbital.pages.length > 0) {
-      return orbital;
-    }
-    const page = strategy === "dashboard" || strategy === "single" ? pages[0] : pages[index];
-    return {
-      ...orbital,
-      pages: page ? [page] : []
-    };
-  });
-  const ledger = mergeLedgers(rawInputs);
-  const schemaVersion = mergeSchemaVersions(rawInputs);
-  const schema = {
-    name: appName,
-    version: "1.0.0",
-    orbitals: orbitalsWithPages,
-    ...schemaVersion !== void 0 ? { schemaVersion } : {},
-    ...ledger !== void 0 ? { ledger } : {}
-  };
-  return {
-    schema,
-    layout: {
-      strategy,
-      pageCount: pages.length
-    },
-    wiring: {
-      connections: eventWiring?.length ?? 0
-    }
-  };
-}
-
-export { composeBehaviors };

package/dist/client/ServerBridge.d.ts

@@ -1,126 +0,0 @@
-import { IEventBus } from '../runtime/types.js';
-import { EventPayload, EmittedEvent } from '@almadar/core';
-import '../service/default-call-service.js';
-import '../service/service-provider.js';
-import '../kernel/program-effects.js';
-import '../runtime/effects/composition/compose-behaviors.js';
-import '../runtime/effects/composition/event-wiring.js';
-import '../runtime/effects/composition/layout-strategy.js';
-import '../runtime/effects/composition/pipe.js';
-
-/**
- * ServerBridge - Client-Server Trait Communication
- *
- * Bridges the client EventBus with the server OrbitalRuntime:
- * 1. Forwards specified events from client to server
- * 2. Receives events from server (via polling or WebSocket)
- * 3. Puts server events onto client EventBus
- *
- * This enables cross-orbital communication between client and server traits.
- *
- * @example
- * ```typescript
- * import { ServerBridge } from '@kflow-builder/shared/runtime';
- * import { useEventBus } from './hooks/useEventBus';
- *
- * // In your app initialization
- * const eventBus = useEventBus();
- * const bridge = new ServerBridge({
- *   eventBus,
- *   serverUrl: '/api/orbitals',
- *   // Events to forward from client to server
- *   forwardEvents: ['ORDER_PLACED', 'PAYMENT_COMPLETED'],
- * });
- *
- * bridge.connect();
- *
- * // Now when client emits ORDER_PLACED, server traits receive it
- * eventBus.emit('ORDER_PLACED', { orderId: '123' });
- * ```
- *
- * @packageDocumentation
- */
-
-interface ServerBridgeConfig {
-    /** Client EventBus to bridge */
-    eventBus: IEventBus;
-    /** Base URL for orbital server API */
-    serverUrl: string;
-    /** Events to forward from client to server */
-    forwardEvents?: string[];
-    /** Forward all events matching pattern (e.g., 'Order*', '*') */
-    forwardPattern?: string;
-    /** Target orbital for forwarded events (or 'broadcast' for all) */
-    targetOrbital?: string;
-    /** Enable WebSocket for real-time server events */
-    useWebSocket?: boolean;
-    /** Polling interval in ms (if not using WebSocket) */
-    pollInterval?: number;
-    /** Enable debug logging */
-    debug?: boolean;
-    /** Custom fetch function (for testing or custom auth) */
-    fetch?: typeof fetch;
-}
-interface ServerBridgeState {
-    connected: boolean;
-    lastError?: string;
-    eventsForwarded: number;
-    eventsReceived: number;
-}
-/**
- * Bridges client EventBus with server OrbitalRuntime
- */
-declare class ServerBridge {
-    private config;
-    private state;
-    private unsubscribes;
-    private pollTimer?;
-    private ws?;
-    private fetchFn;
-    /** The one HTTP request/response leg — shared with `@almadar/ui`'s transport (P5, EventTransport.ts). */
-    private transport;
-    constructor(config: ServerBridgeConfig);
-    /**
-     * Connect the bridge - start forwarding events
-     */
-    connect(): void;
-    /**
-     * Disconnect the bridge
-     */
-    disconnect(): void;
-    /**
-     * Get current bridge state
-     */
-    getState(): ServerBridgeState;
-    private setupEventForwarding;
-    private forwardToServer;
-    private sendEventToOrbital;
-    private fetchOrbitals;
-    private setupPolling;
-    private setupWebSocket;
-    /**
-     * Send an event directly to a specific orbital (bypassing EventBus)
-     */
-    sendEvent(orbitalName: string, event: string, payload?: EventPayload): Promise<{
-        success: boolean;
-        states?: Record<string, string>;
-        emittedEvents?: EmittedEvent[];
-        error?: string;
-    }>;
-    /**
-     * Get current state of an orbital's traits
-     */
-    getOrbitalState(orbitalName: string): Promise<{
-        success: boolean;
-        states?: Record<string, string>;
-        error?: string;
-    }>;
-    private log;
-}
-/**
- * Create a ServerBridge instance
- */
-declare function createServerBridge(config: ServerBridgeConfig): ServerBridge;
-
-export { ServerBridge, createServerBridge };
-export type { ServerBridgeConfig, ServerBridgeState };

package/dist/client/ServerBridge.js

@@ -1,3 +0,0 @@
-export { ServerBridge, createServerBridge } from '../chunk-D5USD2EX.js';
-import '../chunk-QELZ6TEJ.js';
-import '../chunk-MLKGABMK.js';

package/dist/credentials/seed.d.ts

@@ -1,21 +0,0 @@
-import { CredentialStore } from './store.js';
-import '@almadar/core';
-
-/** One credential the app declares: the service group it belongs to and the env var / credential name. */
-interface DeclaredCredential {
-    readonly service: string;
-    readonly envVar: string;
-}
-/** The kernel export that decides a seed (`credential_admin::seed_plan`): the rows to copy, never a value. */
-interface CredentialSeedKernel {
-    credentialSeedPlan(declaredJson: string, heldJson: string, presentJson: string): string;
-}
-/**
- * The boot of `ALMADAR_CREDENTIALS_SOURCE=store`: the kernel plans which declared credentials the store lacks and the env
- * holds, and this copies each into the store, so the env stays the way to hand a deployment its first keys. A name
- * declared twice seeds once, a held row is never overwritten. Returns the count.
- */
-declare function seedCredentialStore(store: CredentialStore, declared: readonly DeclaredCredential[], env: Record<string, string | undefined>, kernel: CredentialSeedKernel): Promise<number>;
-
-export { seedCredentialStore };
-export type { CredentialSeedKernel, DeclaredCredential };

package/dist/credentials/seed.js

@@ -1,2 +0,0 @@
-export { seedCredentialStore } from '../chunk-SWPDU752.js';
-import '../chunk-MLKGABMK.js';

package/dist/credentials/store.d.ts

@@ -1,110 +0,0 @@
-import { PersistenceAdapter, CredentialIdentity } from '@almadar/core';
-
-/** Entity type the credential rows persist under (never a `.lolo`-declared entity). */
-declare const CREDENTIAL_ENTITY_TYPE = "AlmadarIntegrationCredential";
-/** Env var holding the 64-char-hex AES-256 master key (Secret Manager in production). */
-declare const CREDENTIAL_MASTER_KEY_ENV = "ALMADAR_CREDENTIAL_MASTER_KEY";
-/**
- * Env var holding the PREVIOUS master key during a rotation window (I-28):
- * decryption tries the row's stamped key, `rotate()` re-encrypts every row
- * under the current key, then the previous key is retired from the env.
- */
-declare const CREDENTIAL_PREVIOUS_MASTER_KEY_ENV = "ALMADAR_CREDENTIAL_MASTER_KEY_PREVIOUS";
-/** The slice of the persistence contract the credential store uses. */
-type CredentialPersistence = Pick<PersistenceAdapter, 'create' | 'update' | 'delete' | 'list'>;
-/** Entity type the shared one-use values (a pending OAuth grant) persist under. */
-declare const DERIVED_ENTITY_TYPE = "AlmadarKernelDerivedSecret";
-/** What an adapter also offers when it can share one-use values across instances: a read by id, and a conditional delete where the store has one. */
-type DerivedPersistence = Pick<PersistenceAdapter, 'getById'> & Partial<Pick<PersistenceAdapter, 'writeWhere' | 'writeCapabilities'>>;
-/** Masked view of one stored credential — safe to return to a settings page. */
-interface CredentialEntry {
-    service: string;
-    envVar: string;
-    last4: string;
-    updatedAt: number;
-    principal?: CredentialIdentity['principal'];
-}
-/**
- * Tenant-scoped (app-wide) credential store: one AES-256-GCM-encrypted row
- * per (service, envVar) through the host's persistence adapter, master key
- * `ALMADAR_CREDENTIAL_MASTER_KEY` held alone in the platform secret store.
- *
- * Resolution contract: credential keys ARE env-var names (the same names
- * `serviceCredentials` declares and `connectionRef` carries), so a stored
- * value transparently shadows its env counterpart — store → env →
- * unconfigured, everywhere.
- *
- * `warm()` decrypts all rows into memory so resolution stays synchronous;
- * every write re-warms the affected entry and notifies subscribers (the
- * `RuntimeIntegrationManager` re-configures on that signal, so new keys go
- * live without a restart).
- */
-declare class CredentialStore {
-    private readonly adapter;
-    private readonly masterKeyHex;
-    private readonly previousKeyHex;
-    private readonly byIdentity;
-    private readonly listeners;
-    private warmed;
-    constructor(adapter: CredentialPersistence, masterKey?: string, previousMasterKey?: string);
-    /** True when a valid master key is present (writes and decryption enabled). */
-    get enabled(): boolean;
-    /** Subscribe to credential changes; returns an unsubscribe function. */
-    subscribe(listener: (principal?: string) => void): () => void;
-    private notify;
-    private encrypt;
-    private decryptWithKey;
-    /**
-     * Decrypt one row, selecting the key by the row's stamped `keyId` (I-28):
-     * current key first, then the rotation-window previous key. Legacy rows
-     * (no `keyId`) try current then previous. Returns null when no held key
-     * decrypts the row — the row is unreadable, never silently wrong (GCM
-     * auth tags make a wrong-key success impossible).
-     */
-    private decryptRow;
-    /**
-     * Load and decrypt every stored row into memory. Returns the number of
-     * resolvable credentials. Without a master key nothing decrypts (rows are
-     * left in place, resolution falls through to env).
-     */
-    warm(): Promise<number>;
-    /** Resolve one credential by env-var name (warmed values only). */
-    resolve(envVar: string, principal?: string): string | undefined;
-    /** The non-secret account label stored in the clear beside a credential's ciphertext; undefined when its row carries none. */
-    label(envVar: string, principal?: string): string | undefined;
-    /** All warmed values as an env-shaped map, for merging over the process env. */
-    snapshotEnv(): Record<string, string>;
-    /** Masked entries for display — never includes plaintext. */
-    entries(principal?: string): CredentialEntry[];
-    /**
-     * Upsert one credential (encrypts, persists, re-warms the entry, notifies). `label` is a non-secret account name kept
-     * in the clear in the row beside the ciphertext; left out, the row's label stays as it is.
-     */
-    set(service: string, envVar: string, value: string, principal?: string, label?: string): Promise<CredentialEntry>;
-    /**
-     * Re-encrypt every readable row under the CURRENT master key (I-28).
-     * Rotation window: deploy the new key as `ALMADAR_CREDENTIAL_MASTER_KEY`
-     * with the old one as `..._PREVIOUS`, call `rotate()`, then retire the
-     * previous key. Rows no held key can read are counted, never dropped.
-     */
-    rotate(): Promise<{
-        rotated: number;
-        alreadyCurrent: number;
-        unreadable: number;
-    }>;
-    /** Whether one-use values are shared through the adapter: a master key and an adapter that reads a row by id. */
-    get sharesDerived(): boolean;
-    /** Keep `value` encrypted in the adapter until `expiresAt` (epoch ms) so any instance on the same store can take it once. */
-    holdDerived(name: string, value: string, expiresAt: number, principal?: string): Promise<void>;
-    /**
-     * Remove and return a held value. Where the adapter has a conditional delete only the instance whose delete
-     * lands gets the value; elsewhere the delete is unconditional, so two instances racing for one state can both
-     * read it. An expired value is consumed and not returned.
-     */
-    takeDerived(name: string, principal: string | undefined, now: number): Promise<string | undefined>;
-    /** Delete one credential row; resolution falls back to env afterwards. */
-    remove(envVar: string, principal?: string): Promise<boolean>;
-}
-
-export { CREDENTIAL_ENTITY_TYPE, CREDENTIAL_MASTER_KEY_ENV, CREDENTIAL_PREVIOUS_MASTER_KEY_ENV, CredentialStore, DERIVED_ENTITY_TYPE };
-export type { CredentialEntry, CredentialPersistence, DerivedPersistence };

package/dist/credentials/store.js

@@ -1,2 +0,0 @@
-export { CREDENTIAL_ENTITY_TYPE, CREDENTIAL_MASTER_KEY_ENV, CREDENTIAL_PREVIOUS_MASTER_KEY_ENV, CredentialStore, DERIVED_ENTITY_TYPE } from '../chunk-NAECVIAR.js';
-import '../chunk-MLKGABMK.js';

package/dist/index-hT1xCdTq.d.ts

@@ -1,46 +0,0 @@
-import { ComposeBehaviorsInput, ComposeBehaviorsResult, composeBehaviors } from './runtime/effects/composition/compose-behaviors.js';
-import { EventWiringEntry, applyEventWiring } from './runtime/effects/composition/event-wiring.js';
-import { LayoutStrategy, detectLayoutStrategy } from './runtime/effects/composition/layout-strategy.js';
-import { PipeStep, pipeBehaviors } from './runtime/effects/composition/pipe.js';
-
-/**
- * Composition Module
- *
- * Runtime-side TypeScript composition layer for behavior/* operators.
- *
- * Composition is normally a compile-time concept, evaluated by the Rust
- * compiler pass before code generation. The runtime ships an equivalent
- * TypeScript implementation so dev-mode hot reload, agent-driven dynamic
- * composition, and the legacy `composeBehaviors()` callers all have a
- * usable in-process implementation. The handlers are wired into
- * `EffectExecutor` as optional handlers (`composeBehaviors`,
- * `applyEventWiring`, `detectLayoutStrategy`, `pipeBehaviors`) so
- * consumers that do not need composition pay no cost.
- *
- * @packageDocumentation
- */
-
-declare const index_ComposeBehaviorsInput: typeof ComposeBehaviorsInput;
-declare const index_ComposeBehaviorsResult: typeof ComposeBehaviorsResult;
-declare const index_EventWiringEntry: typeof EventWiringEntry;
-declare const index_LayoutStrategy: typeof LayoutStrategy;
-declare const index_PipeStep: typeof PipeStep;
-declare const index_applyEventWiring: typeof applyEventWiring;
-declare const index_composeBehaviors: typeof composeBehaviors;
-declare const index_detectLayoutStrategy: typeof detectLayoutStrategy;
-declare const index_pipeBehaviors: typeof pipeBehaviors;
-declare namespace index {
-  export {
-    index_ComposeBehaviorsInput as ComposeBehaviorsInput,
-    index_ComposeBehaviorsResult as ComposeBehaviorsResult,
-    index_EventWiringEntry as EventWiringEntry,
-    index_LayoutStrategy as LayoutStrategy,
-    index_PipeStep as PipeStep,
-    index_applyEventWiring as applyEventWiring,
-    index_composeBehaviors as composeBehaviors,
-    index_detectLayoutStrategy as detectLayoutStrategy,
-    index_pipeBehaviors as pipeBehaviors,
-  };
-}
-
-export { index as i };

package/dist/kernel/beacon.d.ts

@@ -1,32 +0,0 @@
-/** The keepalive fetch a beacon falls back to: always the same method, mode and `text/plain` header. */
-interface BeaconFetchInit {
-    method: 'POST';
-    body: string;
-    keepalive: true;
-    mode: 'cors';
-    headers: {
-        'Content-Type': 'text/plain';
-    };
-}
-/** What a host offers a beacon: a queue that may accept the text (true) or decline, and a status-only fetch. */
-interface BeaconDeliveryPorts {
-    queue?: (url: string, text: string) => boolean;
-    fetch: (url: string, init: BeaconFetchInit) => Promise<{
-        status: number;
-    }>;
-}
-/** How a beacon was taken: the queue accepted it, or one fetch answered `status` (null when the fetch threw). */
-type BeaconDelivery = {
-    via: 'queue';
-} | {
-    via: 'fetch';
-    status: number | null;
-};
-/**
- * The queue-first, fetch-fallback decision, once. text/plain keeps the request CORS "simple": no preflight,
- * adblocker-friendly when proxied. A declined, throwing or absent queue falls back; the fetch body is never read.
- */
-declare function deliverBeacon(url: string, text: string, ports: BeaconDeliveryPorts): Promise<BeaconDelivery>;
-
-export { deliverBeacon };
-export type { BeaconDelivery, BeaconDeliveryPorts, BeaconFetchInit };

package/dist/kernel/beacon.js

@@ -1,2 +0,0 @@
-export { deliverBeacon } from '../chunk-VMOBW7RK.js';
-import '../chunk-MLKGABMK.js';