@runbound/config-browser 0.0.0-stage → 0.1.0-alpha.1

package/dist/internal/config-contract/experimentation.d.ts

@@ -0,0 +1,460 @@
+import type { ConfigAllocationReservationClass, ConfigRuleAllocation } from "./decisioning.js";
+export declare const configExperimentContractVersion: "runbound.config.experimentation.v1";
+export declare const configExperimentLimits: Readonly<{
+    maximumActions: 64;
+    maximumArms: 64;
+    maximumArtifactBytes: 1048576;
+    maximumDiagnostics: 256;
+    maximumDimensions: 32;
+    maximumFactors: 12;
+    maximumFactorialCells: 4096;
+    maximumInputPartitions: 10000;
+    maximumMetricRevisions: 256;
+    maximumProbabilityEntries: 64;
+    maximumSwitchbackPeriods: 10000;
+}>;
+export type ConfigExperimentDigest = `sha256:${string}`;
+export type ConfigExperimentLifecycle = "approved" | "archived" | "draft" | "finalized" | "finalizing" | "paused" | "running" | "scheduled" | "stopped" | "validated";
+export type ConfigExperimentEvidenceStrength = "advisory" | "confirmatory" | "exploratory";
+/**
+ * Every durable experiment artifact is bound to the same immutable ingress
+ * authority.  Do not reduce this to a tenant/project/config prefix: the app,
+ * environment, and assignment are independently reusable identifiers.
+ */
+export type ConfigExperimentArtifactScope = Readonly<{
+    appId: string;
+    assignmentId: string;
+    configId: string;
+    createdAt: string;
+    environmentId: string;
+    projectId: string;
+    tenantId: string;
+}>;
+type ArtifactScope = ConfigExperimentArtifactScope;
+export type ConfigExperimentArm = Readonly<{
+    armId: string;
+    role: "control" | "treatment";
+    treatmentDigest: ConfigExperimentDigest;
+    variationIds: readonly string[];
+}>;
+export type ConfigExperimentFactor = Readonly<{
+    factorId: string;
+    levels: readonly Readonly<{
+        levelId: string;
+        treatmentDigest: ConfigExperimentDigest;
+    }>[];
+}>;
+export type ConfigExperimentFactorialCell = Readonly<{
+    cellId: string;
+    levels: Readonly<Record<string, string>>;
+    treatmentDigest: ConfigExperimentDigest;
+}>;
+export type ConfigExperimentDesign = Readonly<{
+    arms: readonly ConfigExperimentArm[];
+    designKind: "aa" | "ab" | "abn" | "treatmentBundle";
+}> | Readonly<{
+    cells: readonly ConfigExperimentFactorialCell[];
+    designKind: "factorialFractional" | "factorialFull";
+    factors: readonly ConfigExperimentFactor[];
+    interactions: readonly (readonly string[])[];
+}> | Readonly<{
+    arms: readonly ConfigExperimentArm[];
+    clusterContextKind: string;
+    designKind: "cluster";
+}> | Readonly<{
+    arms: readonly ConfigExperimentArm[];
+    designKind: "switchback";
+    periodSeconds: number;
+    periods: readonly Readonly<{
+        armId: string;
+        endsAt: string;
+        periodId: string;
+        startsAt: string;
+    }>[];
+    washoutSeconds: number;
+}>;
+export type ConfigExperimentContrast = Readonly<{
+    comparisonIds: readonly string[];
+    contrastId: string;
+    contrastKind: "armDifference" | "factorInteraction" | "factorMainEffect";
+    hypothesis: "equivalence" | "nonInferiority" | "superiority";
+    metricRevisionIds: readonly string[];
+    referenceIds: readonly string[];
+}>;
+export type ConfigExperimentPlanning = Readonly<{
+    alpha: number;
+    minimumDetectableEffect: number;
+    plannedDurationSeconds: number;
+    planningMode: "power";
+    targetPower: number;
+}> | Readonly<{
+    alpha: number;
+    plannedDurationSeconds: number;
+    planningMode: "precision";
+    targetPrecision: number;
+}>;
+export type ConfigExperimentDecisionThresholds = Readonly<{
+    maximumCrossoverRate: number;
+    maximumMissingRate: number;
+    minimumDurationSeconds: number;
+    minimumSampleSize: number;
+    minimumSrmPValue: number;
+    practicalSignificance: number;
+}>;
+export type ConfigExperimentPopulation = Readonly<{
+    eligibility: "allEligible" | "segmentIntersection" | "segmentUnion";
+    exclusionSegmentRevisionIds: readonly string[];
+    inclusionSegmentRevisionIds: readonly string[];
+    noncomplianceHandling: "excludeFromModifiedIntentionToTreat" | "retainInPrimary" | "secondaryOnly";
+    primaryAnalysisPopulation: "assignmentBasedEligible" | "modifiedIntentionToTreat";
+    secondaryAnalysisPopulations: readonly ("asTreated" | "exposureConditioned" | "perProtocol")[];
+}>;
+export type ConfigExperimentMetricAnalysisRule = Readonly<{
+    attributionAnchor: "assignment" | "exposure";
+    censoringPolicy: "exclude" | "rightCensor" | "zeroFill";
+    identityTransitionPolicy: "block" | "freezeAtAssignment" | "resolveAsOfOutcome" | "separateTransitionedPopulation";
+    lateDataPolicy: "blockFinalization" | "includeUntilWatermark" | "successorReanalysis";
+    maturitySeconds: number;
+    metricRevisionId: string;
+    missingDataPolicy: "block" | "exclude" | "zeroFill";
+    outlierPolicy: "none" | "robust" | "winsorized";
+    role: "guardrail" | "invariant" | "primary" | "secondary";
+}>;
+export type ConfigExperimentProtocol = ArtifactScope & Readonly<{
+    allowedAutomaticActions: readonly ("pauseForDataQuality" | "pauseForHarm" | "rollbackToControl")[];
+    analysisProfileId: string;
+    contrasts: readonly ConfigExperimentContrast[];
+    decisionThresholds: ConfigExperimentDecisionThresholds;
+    decisionQuestion: string;
+    formatVersion: "runbound.config.experiment-protocol.v1";
+    hypothesis: string;
+    intendedAction: string;
+    integrityGateIds: readonly string[];
+    multiplicity: Readonly<{
+        alpha: number;
+        familyId: string;
+        method: "benjaminiHochberg" | "bonferroni" | "holm" | "none";
+    }>;
+    owner: string;
+    planning: ConfigExperimentPlanning;
+    protocolId: string;
+    revision: number;
+    varianceReduction: "cupac" | "cuped" | "none" | "regressionAdjustment";
+}>;
+export type ConfigExperimentLayer = ArtifactScope & Readonly<{
+    allocation: ConfigRuleAllocation;
+    interferencePolicy: "mutuallyExclusive" | "orthogonal";
+    layerId: string;
+    layerRevisionId: string;
+    formatVersion: "runbound.config.experiment-layer.v1";
+    revision: number;
+    scope: "app" | "decisionFamily" | "global";
+}>;
+export type ConfigExperimentHoldout = ArtifactScope & Readonly<{
+    allocation: ConfigRuleAllocation;
+    contaminationPolicy: "block" | "diagnoseAndExclude";
+    controlTreatmentDigest: ConfigExperimentDigest;
+    endsAt?: string;
+    formatVersion: "runbound.config.experiment-holdout.v1";
+    holdoutId: string;
+    holdoutRevisionId: string;
+    includedDecisionIds: readonly string[];
+    metricRevisionIds: readonly string[];
+    revision: number;
+    scope: "app" | "decision" | "global" | "layer";
+    startsAt: string;
+}>;
+export type ConfigExperimentIteration = ArtifactScope & Readonly<{
+    allocation: ConfigRuleAllocation;
+    analysisUnitContextKind: string;
+    compatibleSoftwareReleaseIds: readonly string[];
+    design: ConfigExperimentDesign;
+    environmentId: string;
+    estimand: "intentionToTreat" | "modifiedIntentionToTreat";
+    contextContractRevisionId: string;
+    exclusionRevisionId: string;
+    exposurePolicyRevisionId: string;
+    formatVersion: "runbound.config.experiment-iteration.v1";
+    holdoutRevisionId?: string;
+    iterationId: string;
+    layerRevisionId: string;
+    metricAnalysisRules: readonly ConfigExperimentMetricAnalysisRule[];
+    metricRevisionIds: readonly string[];
+    population: ConfigExperimentPopulation;
+    protocolDigest: ConfigExperimentDigest;
+    protocolId: string;
+    randomizationContextKind: string;
+    revision: number;
+    stoppingPolicy: "anytimeValid" | "bayesian" | "fixedHorizon";
+}>;
+export type ConfigExperimentRun = ArtifactScope & Readonly<{
+    assignmentEpoch: number;
+    endsAt?: string;
+    formatVersion: "runbound.config.experiment-run.v1";
+    iterationDigest: ConfigExperimentDigest;
+    iterationId: string;
+    runId: string;
+    startsAt: string;
+    state: ConfigExperimentLifecycle;
+}>;
+export type ConfigExperimentMetricKind = "binary" | "composite" | "continuous" | "count" | "funnel" | "quantile" | "rate" | "ratio" | "repeatedWindow" | "retention" | "timeToEvent";
+export type ConfigExperimentMetricDefinition = ArtifactScope & Readonly<{
+    aggregationUnitContextKind: string;
+    attributionAnchor: "assignment" | "exposure";
+    censoringPolicy: "exclude" | "rightCensor" | "zeroFill";
+    dimensions: readonly string[];
+    direction: "decrease" | "increase" | "invariant";
+    formatVersion: "runbound.config.experiment-metric.v1";
+    identityColumn: string;
+    kind: ConfigExperimentMetricKind;
+    maturitySeconds: number;
+    metricId: string;
+    metricRevisionId: string;
+    minimumCohortSize: number;
+    minimumMeaningfulChange: number;
+    observationWindowSeconds: number;
+    outlierPolicy: "none" | "robust" | "winsorized";
+    residency: "eu" | "uk" | "us";
+    retentionDays: number;
+    revision: number;
+    sensitivity: "internal" | "public" | "restricted";
+    sourceRevision: string;
+    sourceType: "hostedEvent" | "warehouse";
+    timestampColumn: string;
+    valueColumns: readonly string[];
+}>;
+type TransportEvent = ArtifactScope & Readonly<{
+    appId: string;
+    environmentId: string;
+    eventId: string;
+    holdoutRevisionId: string | null;
+    layerRevisionId: string;
+    occurredAt: string;
+    producerEpoch: string;
+    producerId: string;
+    producerSequence: string;
+    producerSessionId: string;
+    receivedAt: string;
+    runId: string;
+}>;
+type ExperimentEventIdentity = Readonly<{
+    assignmentEpoch: number;
+    assignmentUnitToken: string;
+    iterationId: string;
+    qaOverride?: Readonly<{
+        exclusionPolicy: "excludeFromConfirmatoryAndWinnerSelection";
+        overrideId: string;
+    }>;
+    semanticBoundaryId: string;
+    switchbackPeriodId?: string;
+}>;
+export type ConfigExperimentAssignmentEvent = TransportEvent & ExperimentEventIdentity & Readonly<{
+    activationSetId: string;
+    allocationNamespace: string;
+    allocationRevision: number;
+    armId: string;
+    assignmentReason: "adaptive" | "deterministic" | "fallback" | "imported";
+    assignmentReceiptDigest: ConfigExperimentDigest;
+    decisionArtifactDigest: ConfigExperimentDigest;
+    formatVersion: "runbound.config.experiment-assignment.v1";
+    iterationDigest: ConfigExperimentDigest;
+    probabilityVector?: readonly Readonly<{
+        actionId: string;
+        probability: number;
+    }>[];
+    reservationClass: ConfigAllocationReservationClass;
+    selectedProbability: number;
+    softwareReleaseId: string;
+    stateArtifactDigest?: ConfigExperimentDigest;
+    stateRevisionId?: string;
+}>;
+export type ConfigExperimentExposureEvent = TransportEvent & ExperimentEventIdentity & Readonly<{
+    activationSetId: string;
+    armId: string;
+    assignmentReason: "adaptive" | "deterministic" | "fallback" | "imported";
+    decisionArtifactDigest: ConfigExperimentDigest;
+    evidenceStrength: ConfigExperimentEvidenceStrength;
+    exposurePolicyRevisionId: string;
+    fallbackPosture: "none" | "offline" | "safeFallback";
+    formatVersion: "runbound.config.experiment-exposure.v1";
+    iterationDigest: ConfigExperimentDigest;
+    occurrenceKind: "committedRender" | "explicitApplication" | "sdkEvaluation" | "serverBoundary";
+    occurrenceWindowId?: string;
+    probabilityVector?: readonly Readonly<{
+        actionId: string;
+        probability: number;
+    }>[];
+    selectedProbability: number;
+    softwareReleaseId: string;
+    stateArtifactDigest?: ConfigExperimentDigest;
+    stateRevisionId?: string;
+}>;
+export type ConfigExperimentObservationEvent = TransportEvent & Readonly<{
+    analysisUnitToken: string;
+    dimensionValues: Readonly<Record<string, boolean | number | string>>;
+    formatVersion: "runbound.config.experiment-observation.v1";
+    metricRevisionId: string;
+    observationId: string;
+    value: boolean | number;
+}>;
+export type ConfigExperimentIdentitySnapshot = ArtifactScope & Readonly<{
+    asOf: string;
+    cardinality: "manyToOne" | "oneToOne";
+    conflictPolicy: "block" | "firstTouch" | "lastTouch" | "timeAsOf";
+    correctionOfSnapshotId?: string;
+    deletionStateDigest: ConfigExperimentDigest;
+    destinationContextKind: string;
+    formatVersion: "runbound.config.experiment-identity-snapshot.v1";
+    mappingDigest: ConfigExperimentDigest;
+    mappingSourceRevision: string;
+    snapshotId: string;
+    sourceContextKind: string;
+}>;
+export type ConfigExperimentWarehouseManifest = ArtifactScope & Readonly<{
+    compiledQueryDigest: ConfigExperimentDigest;
+    connectionRevisionId: string;
+    deletionStateDigest: ConfigExperimentDigest;
+    engine: "athena" | "bigquery" | "databricksSql" | "redshift" | "snowflake";
+    engineJobId: string;
+    engineVersion: string;
+    formatVersion: "runbound.config.experiment-warehouse-manifest.v1";
+    inputWatermarks: readonly Readonly<{
+        sourceId: string;
+        watermark: string;
+    }>[];
+    manifestId: string;
+    mode: "fullSnapshot" | "incremental";
+    outputDigest: ConfigExperimentDigest;
+    parametersDigest: ConfigExperimentDigest;
+    queryPlanDigest: ConfigExperimentDigest;
+    scannedBytes: number;
+}>;
+export type ConfigExperimentSealedInput = ArtifactScope & Readonly<{
+    analysisEngineDigest: ConfigExperimentDigest;
+    assignmentInputDigest: ConfigExperimentDigest;
+    deletionStateDigest: ConfigExperimentDigest;
+    exclusionRevisionId: string;
+    exposureInputDigest: ConfigExperimentDigest;
+    formatVersion: "runbound.config.experiment-sealed-input.v1";
+    identitySnapshotDigest: ConfigExperimentDigest;
+    iterationDigest: ConfigExperimentDigest;
+    metricInputDigests: readonly ConfigExperimentDigest[];
+    metricRevisionIds: readonly string[];
+    partitionDigests: readonly ConfigExperimentDigest[];
+    projectionWatermark: string;
+    runId: string;
+    sealedInputId: string;
+    warehouseManifestDigests: readonly ConfigExperimentDigest[];
+}>;
+export type ConfigExperimentDiagnostic = Readonly<{
+    blocking: boolean;
+    code: string;
+    observed: number;
+    threshold: number;
+}>;
+export type ConfigExperimentAnalysisResult = ArtifactScope & Readonly<{
+    analysisResultId: string;
+    diagnostics: readonly ConfigExperimentDiagnostic[];
+    effects: readonly Readonly<{
+        absolute: number;
+        adjusted: boolean;
+        contrastId: string;
+        intervalLower: number;
+        intervalUpper: number;
+        metricRevisionId: string;
+        practicalThreshold: number;
+        relative: number;
+    }>[];
+    evidenceStrength: ConfigExperimentEvidenceStrength;
+    formatVersion: "runbound.config.experiment-analysis-result.v1";
+    methodDigest: ConfigExperimentDigest;
+    replayability: "replayable" | "sourceDeleted" | "withdrawn";
+    runId: string;
+    sealedInputDigest: ConfigExperimentDigest;
+    status: "blocked" | "complete" | "superseded" | "withdrawn";
+    successorResultId?: string;
+}>;
+export type ConfigExperimentRecommendation = ArtifactScope & Readonly<{
+    analysisResultDigest: ConfigExperimentDigest;
+    compatibleSoftwareReleaseIds: readonly string[];
+    formatVersion: "runbound.config.experiment-recommendation.v1";
+    recommendedArmId?: string;
+    recommendation: "continue" | "inconclusive" | "promote" | "stopForFutility" | "stopForHarm";
+    recommendationId: string;
+    targetConfigReleaseId?: string;
+}>;
+export type ConfigExperimentAdaptivePolicy = ArtifactScope & Readonly<{
+    actions: readonly Readonly<{
+        actionId: string;
+        treatmentDigest: ConfigExperimentDigest;
+    }>[];
+    algorithm: "contextualBandit" | "epsilonGreedy" | "thompsonSampling";
+    contextSchemaDigest: ConfigExperimentDigest;
+    controlReservation: ConfigRuleAllocation;
+    expiresAt: string;
+    explorationFloor: number;
+    fallbackDistribution: readonly Readonly<{
+        actionId: string;
+        probability: number;
+    }>[];
+    formatVersion: "runbound.config.experiment-adaptive-policy.v1";
+    guardrailMetricRevisionIds: readonly string[];
+    maximumProbability: number;
+    maximumTrafficChange: number;
+    minimumProbability: number;
+    objectiveMetricRevisionId: string;
+    policyId: string;
+    policyRevisionId: string;
+    revision: number;
+    trainingNamespace: string;
+}>;
+export type ConfigExperimentAdaptiveState = ArtifactScope & Readonly<{
+    actionProbabilities: readonly Readonly<{
+        actionId: string;
+        probability: number;
+    }>[];
+    compilerDigest: ConfigExperimentDigest;
+    expiresAt: string;
+    featureSchemaRevisionId: string;
+    formatVersion: "runbound.config.experiment-adaptive-state.v1";
+    modelDigest: ConfigExperimentDigest;
+    policyRevisionId: string;
+    predecessorStateRevisionId?: string;
+    signature: string;
+    signatureAlgorithm: "ECDSA_SHA_256" | "Ed25519";
+    stateArtifactDigest: ConfigExperimentDigest;
+    stateRevisionId: string;
+    trainingInputDigest: ConfigExperimentDigest;
+}>;
+export type ConfigExperimentArtifact = ConfigExperimentAdaptivePolicy | ConfigExperimentAdaptiveState | ConfigExperimentAnalysisResult | ConfigExperimentAssignmentEvent | ConfigExperimentExposureEvent | ConfigExperimentHoldout | ConfigExperimentIdentitySnapshot | ConfigExperimentIteration | ConfigExperimentLayer | ConfigExperimentMetricDefinition | ConfigExperimentObservationEvent | ConfigExperimentProtocol | ConfigExperimentRecommendation | ConfigExperimentRun | ConfigExperimentSealedInput | ConfigExperimentWarehouseManifest;
+export type ConfigExperimentEvidenceEligibility = Readonly<{
+    confirmatoryEligible: boolean;
+    reason: "eligible" | "qaOverride";
+    winnerSelectionEligible: boolean;
+}>;
+export declare function validateConfigExperimentArtifact(value: unknown): asserts value is ConfigExperimentArtifact;
+export declare function configExperimentArtifactDigest(artifact: ConfigExperimentArtifact): ConfigExperimentDigest;
+/**
+ * Classifies an assignment or exposure before it can enter a confirmatory
+ * projection. QA overrides are always excluded from both analysis and winner
+ * selection; the closed policy marker makes that exclusion portable across
+ * producers without granting the override any decision authority.
+ */
+export declare function configExperimentEventEvidenceEligibility(event: ConfigExperimentAssignmentEvent | ConfigExperimentExposureEvent): ConfigExperimentEvidenceEligibility;
+export declare const validateConfigExperimentProtocol: (value: unknown) => asserts value is ConfigExperimentProtocol;
+export declare const validateConfigExperimentIteration: (value: unknown) => asserts value is ConfigExperimentIteration;
+export declare const validateConfigExperimentRun: (value: unknown) => asserts value is ConfigExperimentRun;
+export declare const validateConfigExperimentLayer: (value: unknown) => asserts value is ConfigExperimentLayer;
+export declare const validateConfigExperimentHoldout: (value: unknown) => asserts value is ConfigExperimentHoldout;
+export declare const validateConfigExperimentMetricDefinition: (value: unknown) => asserts value is ConfigExperimentMetricDefinition;
+export declare const validateConfigExperimentAssignmentEvent: (value: unknown) => asserts value is ConfigExperimentAssignmentEvent;
+export declare const validateConfigExperimentExposureEvent: (value: unknown) => asserts value is ConfigExperimentExposureEvent;
+export declare const validateConfigExperimentObservationEvent: (value: unknown) => asserts value is ConfigExperimentObservationEvent;
+export declare const validateConfigExperimentIdentitySnapshot: (value: unknown) => asserts value is ConfigExperimentIdentitySnapshot;
+export declare const validateConfigExperimentSealedInput: (value: unknown) => asserts value is ConfigExperimentSealedInput;
+export declare const validateConfigExperimentAnalysisResult: (value: unknown) => asserts value is ConfigExperimentAnalysisResult;
+export declare const validateConfigExperimentRecommendation: (value: unknown) => asserts value is ConfigExperimentRecommendation;
+export declare const validateConfigExperimentWarehouseManifest: (value: unknown) => asserts value is ConfigExperimentWarehouseManifest;
+export declare const validateConfigExperimentAdaptivePolicy: (value: unknown) => asserts value is ConfigExperimentAdaptivePolicy;
+export declare const validateConfigExperimentAdaptiveState: (value: unknown) => asserts value is ConfigExperimentAdaptiveState;
+export {};

package/dist/internal/config-contract/schema.d.ts

@@ -0,0 +1,133 @@
+import { type ConfigJsonSchemaProjection, type JsonValue } from "./base.js";
+export declare const configSchemaFormatVersion: "runbound.config.schema.v1";
+export type ConfigSchemaGovernance = Readonly<{
+    compatibility?: "additive" | "breaking" | "stable";
+    deprecated?: boolean;
+    elementIdProperty?: string;
+    exposure?: "private" | "public";
+    fallback?: "literal-default" | "none";
+    lifecycle?: "live" | "startup";
+    localOverride?: boolean;
+    ownerIds?: readonly string[];
+    replacementFieldId?: string;
+    reviewerIds?: readonly string[];
+    secretReference?: boolean;
+    staleness?: "fail-closed" | "use-last-known-good";
+    targeting?: "allowed" | "forbidden";
+    valueKind?: "array" | "boolean" | "integer" | "null" | "number" | "object" | "string";
+}>;
+type ConfigSchemaCommon = Readonly<{
+    default?: JsonValue;
+    description?: string;
+    governance?: ConfigSchemaGovernance;
+}>;
+export type ConfigSchemaNode = (ConfigSchemaCommon & Readonly<{
+    allowedValues?: readonly boolean[];
+    kind: "boolean";
+}>) | (ConfigSchemaCommon & Readonly<{
+    kind: "null";
+}>) | (ConfigSchemaCommon & Readonly<{
+    allowedValues?: readonly string[];
+    format?: "date-time" | "duration" | "email" | "hostname" | "ipv4" | "ipv6" | "uri" | "uuid";
+    kind: "string";
+    length?: Readonly<{
+        max?: number;
+        min?: number;
+    }>;
+    pattern?: string;
+}>) | (ConfigSchemaCommon & Readonly<{
+    allowedValues?: readonly number[];
+    kind: "number" | "integer";
+    range?: Readonly<{
+        max?: number;
+        min?: number;
+    }>;
+}>) | (ConfigSchemaCommon & Readonly<{
+    extraFields: Readonly<{
+        mode: "forbid";
+    }> | Readonly<{
+        mode: "map";
+        schema: ConfigSchemaNode;
+    }>;
+    fields: readonly ConfigSchemaField[];
+    kind: "object";
+}>) | (ConfigSchemaCommon & Readonly<{
+    items: ConfigSchemaNode;
+    kind: "array";
+    length?: Readonly<{
+        max?: number;
+        min?: number;
+    }>;
+}>) | (ConfigSchemaCommon & Readonly<{
+    alternatives: readonly ConfigSchemaNode[];
+    kind: "union";
+}>) | (ConfigSchemaCommon & Readonly<{
+    kind: "reference";
+    name: string;
+}>);
+export type ConfigSchemaField = Readonly<{
+    id: string;
+    name: string;
+    required: boolean;
+    schema: ConfigSchemaNode;
+}>;
+export type ConfigSchema = Readonly<{
+    definitions?: Readonly<Record<string, ConfigSchemaNode>>;
+    formatVersion: typeof configSchemaFormatVersion;
+    root: ConfigSchemaNode;
+}>;
+export type ConfigSchemaDiagnostic = Readonly<{
+    schemaPath: string;
+    code: string;
+    jsonSchemaPath?: string;
+    message: string;
+}>;
+export declare class ConfigSchemaError extends Error {
+    readonly diagnostics: readonly ConfigSchemaDiagnostic[];
+    constructor(message: string, diagnostics: readonly ConfigSchemaDiagnostic[]);
+}
+export declare const configSchemaJsonProjectionMapping: Readonly<{
+    readonly allowedValues: "enum";
+    readonly alternatives: "oneOf";
+    readonly compatibility: "x-runbound-compatibility-intent";
+    readonly default: "default";
+    readonly definitions: "$defs";
+    readonly deprecated: "x-runbound-deprecated";
+    readonly description: "description";
+    readonly elementIdProperty: "x-runbound-element-id-property";
+    readonly exposure: "x-runbound-exposure";
+    readonly extraFields: "additionalProperties";
+    readonly fallback: "x-runbound-fallback";
+    readonly fields: "properties";
+    readonly format: "format";
+    readonly formatVersion: "$schema";
+    readonly id: "x-runbound-field-id";
+    readonly items: "items";
+    readonly kind: "type";
+    readonly lengthMax: "maxItems|maxLength";
+    readonly lengthMin: "minItems|minLength";
+    readonly lifecycle: "x-runbound-lifecycle";
+    readonly localOverride: "x-runbound-local-override";
+    readonly ownerIds: "x-runbound-owner-principal-ids";
+    readonly rangeMax: "maximum";
+    readonly rangeMin: "minimum";
+    readonly referenceName: "$ref";
+    readonly replacementFieldId: "x-runbound-replacement-field-id";
+    readonly reviewerIds: "x-runbound-reviewer-principal-ids";
+    readonly secretReference: "x-runbound-secret-reference";
+    readonly staleness: "x-runbound-staleness";
+    readonly targeting: "x-runbound-targeting";
+    readonly valueKind: "x-runbound-value-kind";
+}>;
+export declare function parseConfigSchema(value: unknown): ConfigSchema;
+export declare function normalizeConfigSchema(document: ConfigSchema): ConfigSchema;
+export declare function validateConfigSchema(value: unknown): asserts value is ConfigSchema;
+export declare function validateConfigDocument(schema: ConfigSchema, value: unknown): asserts value is JsonValue;
+export declare function materializeDefaults(schema: ConfigSchema, value: JsonValue | undefined): JsonValue;
+export declare function compilePublicProjection(schema: ConfigSchema, value: JsonValue): {
+    schema: ConfigSchema;
+    value: JsonValue;
+};
+export declare function configSchemaToJsonSchemaProjection(document: ConfigSchema): ConfigJsonSchemaProjection;
+export declare function configJsonSchemaProjectionToSchema(value: ConfigJsonSchemaProjection): ConfigSchema;
+export {};

package/package.json

@@ -1,6 +1,76 @@
 {
   "name": "@runbound/config-browser",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0-alpha.1",
+  "description": "Runbound Config for the browser: typed configuration snapshots, subscriptions, pinned sessions, refresh and experiment exposure for any framework or none.",
+  "author": "Runbound",
+  "keywords": [
+    "runbound",
+    "config",
+    "configuration",
+    "feature-flags",
+    "browser",
+    "experimentation"
+  ],
+  "homepage": "https://github.com/runbound-io/config/tree/main/sdks/browser#readme",
+  "bugs": {
+    "url": "https://github.com/runbound-io/config/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/runbound-io/config.git",
+    "directory": "sdks/browser"
+  },
+  "license": "SEE LICENSE IN LICENSE",
+  "publishConfig": {
+    "access": "public",
+    "tag": "alpha"
+  },
+  "type": "module",
+  "files": [
+    "dist",
+    "!dist/**/*.map",
+    "CHANGELOG.md",
+    "THIRD_PARTY_NOTICES.md"
+  ],
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./config-context": {
+      "types": "./dist/config-context.d.ts",
+      "import": "./dist/config-context.js",
+      "default": "./dist/config-context.js"
+    },
+    "./config-context-client": {
+      "types": "./dist/config-context-client.d.ts",
+      "import": "./dist/config-context-client.js",
+      "default": "./dist/config-context-client.js"
+    },
+    "./config-delivery-store": {
+      "types": "./dist/config-delivery-store.d.ts",
+      "import": "./dist/config-delivery-store.js",
+      "default": "./dist/config-delivery-store.js"
+    },
+    "./config-experimentation": {
+      "types": "./dist/config-experimentation.d.ts",
+      "import": "./dist/config-experimentation.js",
+      "default": "./dist/config-experimentation.js"
+    },
+    "./config-experiment-committed-render": {
+      "types": "./dist/config-experiment-committed-render.d.ts",
+      "import": "./dist/config-experiment-committed-render.js",
+      "default": "./dist/config-experiment-committed-render.js"
+    },
+    "./config-refresh": {
+      "types": "./dist/config-refresh.d.ts",
+      "import": "./dist/config-refresh.js",
+      "default": "./dist/config-refresh.js"
+    }
+  },
+  "dependencies": {
+    "@noble/hashes": "2.2.0"
+  }
+}