stitchkit 0.93.0 → 0.94.1

package/dist/contract/index.d.ts

@@ -1,8 +0,0 @@
-export { ALL_TRANSPORTS, type BodyHttpSuccessStatus, type ClientRequestOptions, type ContractDef, type ContractMeta, type ContractStreamCompletion, type ContractStreamFraming, defineContract, type EndpointDef, type EndpointFn, type EndpointMcpInputRequired, type EndpointMcpPolicy, type EndpointResponseMeta, type EndpointStreamDescriptor, type EndpointToolAnnotations, type EndpointUiMeta, type FileDescriptor, type HandlerContext, type HeadEndpointDef, type HttpMethod, type HttpSuccessStatus, type McpCallContext, type McpClientInfo, type McpInputRequiredCall, type McpInputRequiredResolver, type McpProgressUpdate, type McpReportProgress, type McpRoundOutcome, type MultipartBufferedFiles, type MultipartDescriptor, type MultipartFile, type MultipartFilePolicy, type PathParams, type ResponseMetadata, type RuntimeContext, type ScopedEndpointFn, type ScopedHttpClient, type ScopedUrlBuilder, type ScopedUrlFn, type StreamFinalLinePolicy, type Transport, type TransportSource, type TypedClient, type TypedHttpClient, type TypedUrlBuilder, } from './define.js';
-export { AppError, appError, badRequest, conflict, type ErrorEnvelope, forbidden, isRetryableStatus, isStitchErrorCode, notFound, rateLimited, STITCH_ERROR_STATUS, type StitchErrorCode, unauthorized, } from './errors.js';
-export { type DefinedAppError, type DefinedErrors, defineErrors, type ErrorDefinition, type ErrorDefinitions, type ErrorDetailsOutput, type ErrorDetailsSchema, type ErrorFactories, type ErrorFactory, type ErrorFactoryArguments, type ErrorVocabularyCode, type ErrorVocabularyMapping, type FrozenErrorDefinitions, type VocabularyCodeMap, } from './errors-factory.js';
-export { type ContractFactoryConfig, type ContractFactoryToolExposure, createContractFactory, type ExplicitScopedDefineContract, type ExplicitToolExposureEndpoints, type FactoryScopedEndpoint, type ScopedContractDef, type ScopedDefineContract, } from './factory.js';
-export { type ManagedFilePath, ManagedFilePathSchema, type ManagedFileRef, ManagedFileRefSchema, } from './file-ref.js';
-export { decodeCursor, encodeCursor, type Paginated, paginatedSchema, } from './pagination.js';
-export { type ContractStreamFrame, ContractStreamFrameSchema, DEFAULT_CONTRACT_STREAM_FRAME_BYTES, } from './stream.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/contract/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/contract/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,cAAc,EACd,KAAK,qBAAqB,EAC1B,KAAK,oBAAoB,EACzB,KAAK,WAAW,EAChB,KAAK,YAAY,EACjB,KAAK,wBAAwB,EAC7B,KAAK,qBAAqB,EAC1B,cAAc,EACd,KAAK,WAAW,EAChB,KAAK,UAAU,EACf,KAAK,wBAAwB,EAC7B,KAAK,iBAAiB,EACtB,KAAK,oBAAoB,EACzB,KAAK,wBAAwB,EAC7B,KAAK,uBAAuB,EAC5B,KAAK,cAAc,EACnB,KAAK,cAAc,EACnB,KAAK,cAAc,EACnB,KAAK,eAAe,EACpB,KAAK,UAAU,EACf,KAAK,iBAAiB,EACtB,KAAK,cAAc,EACnB,KAAK,aAAa,EAClB,KAAK,oBAAoB,EACzB,KAAK,wBAAwB,EAC7B,KAAK,iBAAiB,EACtB,KAAK,iBAAiB,EACtB,KAAK,eAAe,EACpB,KAAK,sBAAsB,EAC3B,KAAK,mBAAmB,EACxB,KAAK,aAAa,EAClB,KAAK,mBAAmB,EACxB,KAAK,UAAU,EACf,KAAK,gBAAgB,EACrB,KAAK,cAAc,EACnB,KAAK,gBAAgB,EACrB,KAAK,gBAAgB,EACrB,KAAK,gBAAgB,EACrB,KAAK,WAAW,EAChB,KAAK,qBAAqB,EAC1B,KAAK,SAAS,EACd,KAAK,eAAe,EACpB,KAAK,WAAW,EAChB,KAAK,eAAe,EACpB,KAAK,eAAe,GACrB,MAAM,UAAU,CAAC;AAClB,OAAO,EACL,QAAQ,EACR,QAAQ,EACR,UAAU,EACV,QAAQ,EACR,KAAK,aAAa,EAClB,SAAS,EACT,iBAAiB,EACjB,iBAAiB,EACjB,QAAQ,EACR,WAAW,EACX,mBAAmB,EACnB,KAAK,eAAe,EACpB,YAAY,GACb,MAAM,UAAU,CAAC;AAClB,OAAO,EACL,KAAK,eAAe,EACpB,KAAK,aAAa,EAClB,YAAY,EACZ,KAAK,eAAe,EACpB,KAAK,gBAAgB,EACrB,KAAK,kBAAkB,EACvB,KAAK,kBAAkB,EACvB,KAAK,cAAc,EACnB,KAAK,YAAY,EACjB,KAAK,qBAAqB,EAC1B,KAAK,mBAAmB,EACxB,KAAK,sBAAsB,EAC3B,KAAK,sBAAsB,EAC3B,KAAK,iBAAiB,GACvB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EACL,KAAK,qBAAqB,EAC1B,KAAK,2BAA2B,EAChC,qBAAqB,EACrB,KAAK,4BAA4B,EACjC,KAAK,6BAA6B,EAClC,KAAK,qBAAqB,EAC1B,KAAK,iBAAiB,EACtB,KAAK,oBAAoB,GAC1B,MAAM,WAAW,CAAC;AACnB,OAAO,EACL,KAAK,eAAe,EACpB,qBAAqB,EACrB,KAAK,cAAc,EACnB,oBAAoB,GACrB,MAAM,YAAY,CAAC;AAEpB,OAAO,EACL,YAAY,EACZ,YAAY,EACZ,KAAK,SAAS,EACd,eAAe,GAChB,MAAM,cAAc,CAAC;AACtB,OAAO,EACL,KAAK,mBAAmB,EACxB,yBAAyB,EACzB,mCAAmC,GACpC,MAAM,UAAU,CAAC"}

package/dist/contract/index.js

@@ -1,55 +0,0 @@
-import {
-  ALL_TRANSPORTS,
-  ContractStreamFrameSchema,
-  DEFAULT_CONTRACT_STREAM_FRAME_BYTES,
-  createContractFactory,
-  decodeCursor,
-  defineContract,
-  defineErrors,
-  encodeCursor,
-  paginatedSchema
-} from "../index-0a349c33.js";
-import"../index-rxfy4cq7.js";
-import {
-  ManagedFilePathSchema,
-  ManagedFileRefSchema
-} from "../index-6k1937bx.js";
-import {
-  AppError,
-  STITCH_ERROR_STATUS,
-  appError,
-  badRequest,
-  conflict,
-  forbidden,
-  isRetryableStatus,
-  isStitchErrorCode,
-  notFound,
-  rateLimited,
-  unauthorized
-} from "../index-2vtcmrj9.js";
-import"../index-kzfs85xp.js";
-import"../index-77fekveh.js";
-export {
-  unauthorized,
-  rateLimited,
-  paginatedSchema,
-  notFound,
-  isStitchErrorCode,
-  isRetryableStatus,
-  forbidden,
-  encodeCursor,
-  defineErrors,
-  defineContract,
-  decodeCursor,
-  createContractFactory,
-  conflict,
-  badRequest,
-  appError,
-  STITCH_ERROR_STATUS,
-  ManagedFileRefSchema,
-  ManagedFilePathSchema,
-  DEFAULT_CONTRACT_STREAM_FRAME_BYTES,
-  ContractStreamFrameSchema,
-  AppError,
-  ALL_TRANSPORTS
-};

package/dist/declaration.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"declaration.d.ts","sourceRoot":"","sources":["../src/declaration.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;;;;GAOG;AACH,eAAO,MAAM,kCAAkC,IAAI,CAAC;AAoBpD,+EAA+E;AAC/E,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAK/D;AAUD;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,aAO3B,CAAC;AAEJ;;;;;;GAMG;AACH,eAAO,MAAM,wBAAwB,uCAQlC,CAAC;AAEJ,yEAAyE;AACzE,eAAO,MAAM,qBAAqB;;;;;kBAOvB,CAAC;AAEZ;;;;GAIG;AACH,eAAO,MAAM,oBAAoB,aAW9B,CAAC;AAEJ,+EAA+E;AAC/E,eAAO,MAAM,qBAAqB,aAEiD,CAAC;AAEpF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,qBAAqB;;;;kBAavB,CAAC;AAEZ,kDAAkD;AAClD,eAAO,MAAM,oBAAoB;;;EAAwC,CAAC;AAoG1E,eAAO,MAAM,oBAAoB;;;kBAKtB,CAAC;AAEZ;;;;;;GAMG;AACH,eAAO,MAAM,wBAAwB;;;kBAMpC,CAAC;AAEF,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;kBA0BnB,CAAC;AAEZ;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,uBAAuB;;;;kBAezB,CAAC;AAEZ,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAExE,gFAAgF;AAChF,eAAO,MAAM,kBAAkB;;;;;;;;;;;kBAciD,CAAC;AAEjF,0CAA0C;AAC1C,eAAO,MAAM,6BAA6B;;;EAA+B,CAAC;AAE1E;;;;;;GAMG;AACH,eAAO,MAAM,wBAAwB;;;;;;kBAK1B,CAAC;AAEZ;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,uBAAuB;;;;kBAMzB,CAAC;AAEZ,2EAA2E;AAC3E,eAAO,MAAM,oBAAoB;;;;;;kBAEtB,CAAC;AAEZ,0EAA0E;AAC1E,eAAO,MAAM,qBAAqB;;;;;;EAA0D,CAAC;AAE7F;;;;;;GAMG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;;;kBAclC,CAAC;AAEJ,6EAA6E;AAC7E,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA0DjC,CAAC;AAyCL,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAC1E,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAC5D,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAClE,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAC1E,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAC1E,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAKpE;;;;;;;;GAQG;AACH,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,OAAO,GAAG,kBAAkB,CAU3E;AAED,+CAA+C;AAC/C,wBAAgB,eAAe,CAC7B,WAAW,EAAE,kBAAkB,EAC/B,IAAI,EAAE,MAAM,GACX,WAAW,GAAG,SAAS,CAEzB"}

package/dist/declaration.js

@@ -1,183 +0,0 @@
-// src/declaration.ts
-import { z } from "zod";
-var PROJECT_DECLARATION_SCHEMA_VERSION = 1;
-var MACHINE_PATTERNS = [
-  [/:\/\//, "an absolute address"],
-  [/^\/\//, "a protocol-relative host"],
-  [/^[~]/, "a home-relative path"],
-  [/^[A-Za-z]:[\\/]/, "a Windows drive path"],
-  [/\\/, "a Windows path separator"],
-  [/(?:^|[\s=:])\d{1,3}(?:\.\d{1,3}){3}(?![\d.])/, "an IP address"],
-  [/(?:^|[\s=])[A-Za-z][\w.-]*:\d{2,5}(?![\w.])/, "a host and port"]
-];
-function namesAMachine(value) {
-  for (const [pattern, reason] of MACHINE_PATTERNS) {
-    if (pattern.test(value))
-      return reason;
-  }
-  return;
-}
-function refuseMachineNames(label) {
-  return (schema) => schema.refine((value) => namesAMachine(value) === undefined, {
-    error: (issue) => `${label} names a machine — ${namesAMachine(String(issue.input)) ?? "a value of the deployment"} is supplied by the deployment, not written in the code`
-  });
-}
-var ProjectSlugSchema = z.string().min(1).max(64).regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/, "Use lowercase letters, numbers and single hyphens (for example: talk-control)");
-var ProjectDescriptionSchema = z.record(refuseMachineNames("A locale tag")(z.string().min(1)), refuseMachineNames("A description")(z.string().trim().min(1))).refine((value) => Object.keys(value).length > 0, "Describe the project in at least one locale");
-var ProjectIdentitySchema = z.object({
-  slug: ProjectSlugSchema,
-  name: refuseMachineNames("A project name")(z.string().trim().min(1).max(80)),
-  version: z.string().regex(/^\d+\.\d+\.\d+$/, "Use a semantic version such as 0.1.0"),
-  description: ProjectDescriptionSchema
-}).strict();
-var RepositoryPathSchema = z.string().min(1).refine((value) => !value.startsWith("/"), "Use a path relative to the repository root").refine((value) => namesAMachine(value) === undefined, {
-  error: (issue) => `A path may not contain ${namesAMachine(String(issue.input)) ?? "a machine name"}`
-}).refine((value) => !value.split("/").includes(".."), "A path may not climb out of the repository");
-var BindingVariableSchema = z.string().regex(/^[A-Z][A-Z0-9_]*$/, "Name an environment variable, for example API_PORT");
-var ProjectListenerSchema = z.object({
-  portVariable: BindingVariableSchema,
-  bindVariable: BindingVariableSchema,
-  readinessPath: refuseMachineNames("A readiness path")(z.string().startsWith("/", "Readiness is a path, for example /health"))
-}).strict();
-var ProjectRunModeSchema = z.enum(["development", "production"]);
-var PROJECT_SCRIPT_LAUNCHERS = [
-  [/^(?:bun|npm|pnpm|yarn)$/, /^run$/],
-  [/^deno$/, /^task$/],
-  [/^(?:npx|bunx|pnpx)$/, null]
-];
-function launchesAScript(executable, firstArgument) {
-  for (const [runner, verb] of PROJECT_SCRIPT_LAUNCHERS) {
-    if (!runner.test(executable))
-      continue;
-    if (verb === null)
-      return true;
-    if (firstArgument !== undefined && verb.test(firstArgument))
-      return true;
-  }
-  return false;
-}
-var PORT_FLAG = /^(?:-p|-{1,2}(?:port|listen))$/i;
-var CommandPartSchema = refuseMachineNames("A command part")(z.string().min(1)).refine((value) => !value.startsWith("/"), "A command part may not be an absolute path — paths are relative to the source").refine((value) => !/^[^=\s]+=/.test(value), "A command part may not carry an inline value — write the flag and its value as separate arguments, so the value is checked like every other one");
-var CommandArgumentsSchema = z.array(CommandPartSchema).refine((args) => args.every((value, index) => !(/^\d{1,5}$/.test(value) && PORT_FLAG.test(args[index - 1] ?? ""))), "A number after a port flag is a port — name the variable that carries it and let the role read it");
-var ProjectCommandSchema = z.object({
-  executable: CommandPartSchema,
-  args: CommandArgumentsSchema
-}).strict();
-var ProjectRoleCommandSchema = ProjectCommandSchema.refine((value) => !launchesAScript(value.executable, value.args[0]), "Start the role process itself, not a script runner: a launcher between the supervisor and the role duplicates the shutdown signal and forces the drain").refine((value) => !value.args.includes("--filter"), "A workspace filter puts a launcher between the supervisor and the role, and the shutdown signal never reaches it");
-var ProjectRoleSchema = z.object({
-  name: ProjectSlugSchema,
-  workingDirectory: RepositoryPathSchema.optional(),
-  commands: z.record(ProjectRunModeSchema, ProjectRoleCommandSchema),
-  listener: ProjectListenerSchema.optional(),
-  drainFloorMs: z.number().int().nonnegative()
-}).strict();
-var ProjectBuildInputSchema = z.object({
-  name: ProjectSlugSchema,
-  path: RepositoryPathSchema,
-  digest: z.string().regex(/^sha256:[0-9a-f]{64}$/, 'Use a lowercase sha256 digest, as "sha256:<64 hex>"')
-}).strict();
-var ProjectBuildSchema = z.object({
-  command: ProjectCommandSchema,
-  artifacts: z.array(RepositoryPathSchema).min(1),
-  inputs: z.array(ProjectBuildInputSchema).optional()
-}).strict().refine((build) => {
-  const names = (build.inputs ?? []).map((input) => input.name);
-  return new Set(names).size === names.length;
-}, "Two build inputs share a name — a failure could then name either of them");
-var ProjectRequirementPhaseSchema = z.enum(["release", "start"]);
-var ProjectRequirementSchema = z.object({
-  name: ProjectSlugSchema,
-  phases: z.array(ProjectRequirementPhaseSchema).min(1)
-}).strict();
-var ProjectMigrationsSchema = z.object({
-  engine: refuseMachineNames("A migration engine name")(z.string().min(1).max(64)),
-  root: RepositoryPathSchema,
-  lockfile: RepositoryPathSchema
-}).strict();
-var ProjectReleaseSchema = z.object({ migrations: ProjectMigrationsSchema.optional() }).strict();
-var ProjectEnvShapeSchema = z.enum(["string", "integer", "boolean", "url", "enum"]);
-var ProjectEnvVariableSchema = z.object({
-  name: BindingVariableSchema,
-  shape: ProjectEnvShapeSchema,
-  required: z.boolean(),
-  members: z.array(refuseMachineNames("An enum member")(z.string().min(1))).min(1).optional()
-}).strict().refine((value) => value.shape === "enum" === (value.members !== undefined), "An enum variable lists its members; every other shape has none");
-var ProjectDeclarationSchema = z.object({
-  schemaVersion: z.literal(PROJECT_DECLARATION_SCHEMA_VERSION),
-  kind: z.enum(["library", "application"]),
-  identity: ProjectIdentitySchema,
-  roles: z.array(ProjectRoleSchema),
-  build: ProjectBuildSchema.optional(),
-  requires: z.array(ProjectRequirementSchema),
-  release: ProjectReleaseSchema,
-  env: z.object({ variables: z.array(ProjectEnvVariableSchema) }).strict()
-}).strict().refine((value) => value.kind === "application" ? value.roles.length > 0 : value.roles.length === 0, "An application declares at least one role; a library declares none").refine((value) => new Set(value.roles.map((role) => role.name)).size === value.roles.length, "Role names must be unique").refine((value) => new Set(value.requires.map((entry) => entry.name)).size === value.requires.length, "Name each requirement once and list its phases").refine((value) => value.requires.every((entry) => new Set(entry.phases).size === entry.phases.length), "List each phase of a requirement once").refine((value) => new Set(value.env.variables.map((entry) => entry.name)).size === value.env.variables.length, "Declare each environment variable once").refine((value) => listenerBindingProblem(value) === undefined, {
-  error: (issue) => listenerBindingProblem(issue.input) ?? "Listener bindings are inconsistent"
-});
-function isListenerBindingSubject(value) {
-  return typeof value === "object" && value !== null && "roles" in value && "env" in value;
-}
-function listenerBindingProblem(value) {
-  if (!isListenerBindingSubject(value))
-    return;
-  const shapes = new Map(value.env.variables.map((entry) => [entry.name, entry.shape]));
-  for (const role of value.roles) {
-    const listener = role.listener;
-    if (!listener)
-      continue;
-    if (listener.portVariable === listener.bindVariable) {
-      return `Role "${role.name}" points its port and its bind address at the same variable "${listener.portVariable}"`;
-    }
-    const expected = [
-      [listener.portVariable, "integer"],
-      [listener.bindVariable, "string"]
-    ];
-    for (const [name, shape] of expected) {
-      const declared = shapes.get(name);
-      if (declared === undefined) {
-        return `Role "${role.name}" listens on "${name}", which env.variables does not declare — a deployment reading this cannot know it has to supply it`;
-      }
-      if (declared !== shape) {
-        return `Role "${role.name}" listens on "${name}", declared as "${declared}" where a ${shape} is needed`;
-      }
-    }
-  }
-  return;
-}
-var VersionProbeSchema = z.object({ schemaVersion: z.unknown() }).loose();
-function parseProjectDeclaration(source) {
-  const probe = VersionProbeSchema.safeParse(source);
-  const declared = probe.success ? probe.data.schemaVersion : undefined;
-  if (declared !== undefined && declared !== PROJECT_DECLARATION_SCHEMA_VERSION) {
-    throw new Error(`Project declaration schema version ${JSON.stringify(declared)} is not supported — ` + `this build understands version ${PROJECT_DECLARATION_SCHEMA_VERSION}.`);
-  }
-  return ProjectDeclarationSchema.parse(source);
-}
-function findProjectRole(declaration, name) {
-  return declaration.roles.find((role) => role.name === name);
-}
-export {
-  parseProjectDeclaration,
-  namesAMachine,
-  findProjectRole,
-  RepositoryPathSchema,
-  ProjectSlugSchema,
-  ProjectRunModeSchema,
-  ProjectRoleSchema,
-  ProjectRoleCommandSchema,
-  ProjectRequirementSchema,
-  ProjectRequirementPhaseSchema,
-  ProjectReleaseSchema,
-  ProjectMigrationsSchema,
-  ProjectListenerSchema,
-  ProjectIdentitySchema,
-  ProjectEnvVariableSchema,
-  ProjectEnvShapeSchema,
-  ProjectDescriptionSchema,
-  ProjectDeclarationSchema,
-  ProjectCommandSchema,
-  ProjectBuildSchema,
-  ProjectBuildInputSchema,
-  PROJECT_DECLARATION_SCHEMA_VERSION,
-  BindingVariableSchema
-};

package/dist/files.d.ts

@@ -1,3 +0,0 @@
-export { type ManagedFilePath, ManagedFilePathSchema, type ManagedFileRef, ManagedFileRefSchema, } from './contract/file-ref.js';
-export { createManagedFileBoundary, type ManagedFileBoundary, type ManagedFileBoundaryConfig, ManagedFileError, type ManagedFileErrorCode, type ManagedFileInspection, type ManagedFileInspectionInput, type ManagedFileInspector, type ManagedFileReadOptions, type ManagedFileSource, type ManagedFileWriteOptions, } from './files/boundary.js';
-//# sourceMappingURL=files.d.ts.map

package/dist/files.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"files.d.ts","sourceRoot":"","sources":["../src/files.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,eAAe,EACpB,qBAAqB,EACrB,KAAK,cAAc,EACnB,oBAAoB,GACrB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EACL,yBAAyB,EACzB,KAAK,mBAAmB,EACxB,KAAK,yBAAyB,EAC9B,gBAAgB,EAChB,KAAK,oBAAoB,EACzB,KAAK,qBAAqB,EAC1B,KAAK,0BAA0B,EAC/B,KAAK,oBAAoB,EACzB,KAAK,sBAAsB,EAC3B,KAAK,iBAAiB,EACtB,KAAK,uBAAuB,GAC7B,MAAM,kBAAkB,CAAC"}

package/dist/files.js

@@ -1,15 +0,0 @@
-import {
-  ManagedFileError,
-  createManagedFileBoundary
-} from "./index-actkayzn.js";
-import"./index-sbdmyz75.js";
-import {
-  ManagedFilePathSchema,
-  ManagedFileRefSchema
-} from "./index-6k1937bx.js";
-export {
-  createManagedFileBoundary,
-  ManagedFileRefSchema,
-  ManagedFilePathSchema,
-  ManagedFileError
-};

package/dist/geo.d.ts

@@ -1,3 +0,0 @@
-/** Server-only GeoIP resolver. Applications own database acquisition/licensing. */
-export * from './geo/index.js';
-//# sourceMappingURL=geo.d.ts.map

package/dist/geo.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"geo.d.ts","sourceRoot":"","sources":["../src/geo.ts"],"names":[],"mappings":"AAAA,mFAAmF;AACnF,cAAc,aAAa,CAAC"}

package/dist/geo.js

@@ -1,245 +0,0 @@
-import {
-  messageOf
-} from "./index-p13mwz16.js";
-import {
-  isPublicIp
-} from "./index-f9mb610r.js";
-import"./index-kzfs85xp.js";
-import {
-  isRecord
-} from "./index-77fekveh.js";
-
-// src/geo/maxmind.ts
-import { realpath, stat } from "node:fs/promises";
-var MAXMIND_PEER = "maxmind";
-async function revisionOf(paths) {
-  try {
-    const entries = await Promise.all([paths.city, paths.asn].filter((path) => path !== undefined).map(async (path) => {
-      const [resolved, metadata] = await Promise.all([realpath(path), stat(path)]);
-      return [
-        resolved,
-        metadata.dev,
-        metadata.ino,
-        metadata.size,
-        Math.trunc(metadata.mtimeMs)
-      ].join(":");
-    }));
-    return entries.join("|");
-  } catch {
-    return null;
-  }
-}
-function createMaxMindGeoIpLoader(options = {}) {
-  const loadPeer = options.loadPeer ?? (() => import(MAXMIND_PEER));
-  return {
-    revision: revisionOf,
-    async open(paths, expectedRevision) {
-      const before = await revisionOf(paths);
-      if (before === null)
-        throw new Error("GeoIP database is unavailable");
-      if (before !== expectedRevision) {
-        throw new Error("GeoIP database changed before opening a generation");
-      }
-      const peer = await loadPeer();
-      if (!peer || typeof peer.open !== "function") {
-        throw new Error("The optional maxmind peer does not expose open()");
-      }
-      const city = await peer.open(paths.city, { watchForUpdates: false });
-      let asn;
-      try {
-        if (paths.asn)
-          asn = await peer.open(paths.asn, { watchForUpdates: false });
-        const after = await revisionOf(paths);
-        if (after !== before)
-          throw new Error("GeoIP database changed while opening a generation");
-        return {
-          lookup(ip) {
-            const cityRecord = city.get(ip);
-            const asnRecord = asn?.get(ip);
-            if (!asnRecord || typeof asnRecord !== "object")
-              return cityRecord;
-            if (!cityRecord || typeof cityRecord !== "object")
-              return asnRecord;
-            return { ...cityRecord, ...asnRecord };
-          },
-          async close() {
-            await Promise.all([city.close?.(), asn?.close?.()]);
-          }
-        };
-      } catch (error) {
-        await Promise.allSettled([city.close?.(), asn?.close?.()]);
-        throw error;
-      }
-    }
-  };
-}
-// src/geo/resolver.ts
-function text(value) {
-  return typeof value === "string" && value.length > 0 ? value : undefined;
-}
-function finite(value) {
-  return typeof value === "number" && Number.isFinite(value) ? value : undefined;
-}
-function record(value) {
-  return isRecord(value) ? value : undefined;
-}
-function mapGeoIpRecord(value) {
-  const root = record(value);
-  if (!root)
-    return null;
-  const country = record(root.country);
-  const subdivisions = Array.isArray(root.subdivisions) ? record(root.subdivisions[0]) : undefined;
-  const city = record(root.city);
-  const postal = record(root.postal);
-  const location = record(root.location);
-  const names = (entry) => record(entry?.names);
-  const result = {
-    countryCode: text(country?.iso_code),
-    countryName: text(names(country)?.en),
-    regionCode: text(subdivisions?.iso_code),
-    regionName: text(names(subdivisions)?.en),
-    city: text(names(city)?.en),
-    postalCode: text(postal?.code),
-    latitude: finite(location?.latitude),
-    longitude: finite(location?.longitude),
-    timezone: text(location?.time_zone),
-    autonomousSystemNumber: finite(root.autonomous_system_number),
-    autonomousSystemOrganization: text(root.autonomous_system_organization)
-  };
-  return Object.values(result).some((entry) => entry !== undefined) ? result : null;
-}
-var errorMessage = (error) => messageOf(error) || "unknown reload error";
-function createGeoIpResolver(options) {
-  const clock = options.clock ?? Date.now;
-  const map = options.map ?? mapGeoIpRecord;
-  let generation = null;
-  let snapshot = Object.freeze({ state: "uninitialized" });
-  let reloadChain = Promise.resolve(false);
-  let timer;
-  let closed = false;
-  const finishRetire = async (current) => {
-    if (current.closing)
-      return current.closePromise ?? Promise.resolve();
-    current.closing = true;
-    try {
-      await current.reader.close?.();
-    } catch (error) {
-      options.onError?.(error);
-    } finally {
-      current.closeResolve?.();
-    }
-  };
-  const retire = (current) => {
-    current.retired = true;
-    if (current.closePromise)
-      return current.closePromise;
-    if (current.lookups > 0) {
-      current.closePromise = new Promise((resolve) => {
-        current.closeResolve = resolve;
-      });
-      return current.closePromise;
-    }
-    current.closePromise = finishRetire(current);
-    return current.closePromise;
-  };
-  const swap = async () => {
-    if (closed)
-      return false;
-    let revision;
-    try {
-      revision = await options.loader.revision(options.paths);
-      if (revision === null)
-        throw new Error("GeoIP database is unavailable");
-      if (generation && revision === generation.revision) {
-        if (snapshot.reloadError) {
-          snapshot = Object.freeze({
-            state: "ready",
-            revision,
-            loadedAt: snapshot.loadedAt
-          });
-        }
-        return false;
-      }
-      const next = await options.loader.open(options.paths, revision);
-      if (closed) {
-        await next.close?.();
-        return false;
-      }
-      const previous = generation;
-      generation = { reader: next, revision, lookups: 0, retired: false };
-      snapshot = Object.freeze({ state: "ready", revision, loadedAt: clock() });
-      if (previous)
-        await retire(previous);
-      return true;
-    } catch (error) {
-      options.onError?.(error);
-      snapshot = generation ? Object.freeze({
-        state: "ready",
-        revision: generation.revision,
-        loadedAt: snapshot.loadedAt,
-        reloadError: errorMessage(error)
-      }) : Object.freeze({ state: "unavailable", reloadError: errorMessage(error) });
-      return false;
-    }
-  };
-  const reload = () => {
-    reloadChain = reloadChain.then(swap, swap);
-    return reloadChain;
-  };
-  const close = async () => {
-    closed = true;
-    if (timer)
-      clearInterval(timer);
-    timer = undefined;
-    await reloadChain.catch(() => {
-      return;
-    });
-    const current = generation;
-    generation = null;
-    if (current)
-      await retire(current);
-    snapshot = Object.freeze({ state: "uninitialized" });
-  };
-  return {
-    id: options.id ?? "geoip",
-    async start() {
-      closed = false;
-      await reload();
-      return { value: this };
-    },
-    activate() {
-      const intervalMs = options.reload === false ? undefined : options.reload?.intervalMs;
-      if (intervalMs !== undefined && intervalMs > 0 && !timer) {
-        timer = setInterval(() => void reload(), intervalMs);
-        timer.unref?.();
-      }
-    },
-    close,
-    force: close,
-    async resolve(ip) {
-      if (!isPublicIp(ip))
-        return null;
-      const current = generation;
-      if (!current)
-        return null;
-      current.lookups += 1;
-      try {
-        return map(await current.reader.lookup(ip));
-      } catch (error) {
-        options.onError?.(error);
-        return null;
-      } finally {
-        current.lookups -= 1;
-        if (current.retired && current.lookups === 0)
-          await finishRetire(current);
-      }
-    },
-    reload,
-    snapshot: () => snapshot
-  };
-}
-export {
-  mapGeoIpRecord,
-  createMaxMindGeoIpLoader,
-  createGeoIpResolver
-};

package/dist/google.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"google.d.ts","sourceRoot":"","sources":["../src/google.ts"],"names":[],"mappings":"AAYA,MAAM,MAAM,mBAAmB,GAC3B,eAAe,GACf,oBAAoB,GACpB,sBAAsB,CAAC;AAQ3B,qBAAa,eAAgB,SAAQ,KAAK;IACxC,QAAQ,CAAC,IAAI,EAAE,mBAAmB,CAAC;IACnC,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAE5B,YAAY,IAAI,EAAE,mBAAmB,EAAE,OAAO,CAAC,EAAE,YAAY,EAK5D;CACF;AAED,MAAM,WAAW,kBAAkB;IACjC,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,gBAAgB;IAC/B,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,uBAAuB;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,MAAM,EAAE,WAAW,CAAC;CACrB;AAED,MAAM,MAAM,wBAAwB,GAAG,CACrC,KAAK,EAAE,uBAAuB,KAC3B,OAAO,CAAC;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC;AAElC,MAAM,MAAM,yBAAyB,GAAG,CAAC,KAAK,EAAE;IAC9C,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;CAClB,KAAK,OAAO,CAAC,gBAAgB,CAAC,CAAC;AAEhC,MAAM,WAAW,sBAAsB;IACrC,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,mBAAmB,EAAE,SAAS,MAAM,EAAE,CAAC;IACvC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,GAAG,GAAG,GAAG,OAAO,EAAE,IAAI,CAAC,EAAE,WAAW,KAAK,OAAO,CAAC,QAAQ,CAAC,CAAC;IACjF,cAAc,CAAC,EAAE,wBAAwB,CAAC;IAC1C,eAAe,CAAC,EAAE,yBAAyB,CAAC;CAC7C;AAED,MAAM,WAAW,oCAAoC;IACnD,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,gBAAgB;IAC/B,yBAAyB,CACvB,KAAK,EAAE,oCAAoC,GAC1C,OAAO,CAAC,kBAAkB,CAAC,CAAC;CAChC;AAqGD,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,sBAAsB,GAAG,gBAAgB,CAmFvF"}