@localpreview/protocol 0.1.0

package/dist/errors.d.ts

@@ -0,0 +1,13 @@
+import { Schema } from "effect";
+export declare const ErrorCodeSchema: Schema.Literals<readonly ["BODY_TOO_LARGE", "INVALID_SUBDOMAIN", "REQUEST_TIMEOUT", "REQUEST_FAILED", "RELAY_REGISTRATION_FAILED", "SANDBOX_CREATE_FAILED", "SUBDOMAIN_TAKEN", "TUNNEL_NOT_CONNECTED", "TUNNEL_NOT_FOUND", "UNAUTHORIZED"]>;
+export type ErrorCode = Schema.Schema.Type<typeof ErrorCodeSchema>;
+export declare const LocalPreviewErrorSchema: Schema.Struct<{
+    readonly code: Schema.Literals<readonly ["BODY_TOO_LARGE", "INVALID_SUBDOMAIN", "REQUEST_TIMEOUT", "REQUEST_FAILED", "RELAY_REGISTRATION_FAILED", "SANDBOX_CREATE_FAILED", "SUBDOMAIN_TAKEN", "TUNNEL_NOT_CONNECTED", "TUNNEL_NOT_FOUND", "UNAUTHORIZED"]>;
+    readonly message: Schema.String;
+    readonly requestId: Schema.optional<Schema.String>;
+    readonly subdomain: Schema.optional<Schema.String>;
+    readonly limitBytes: Schema.optional<Schema.Number>;
+}>;
+export type LocalPreviewError = Schema.Schema.Type<typeof LocalPreviewErrorSchema>;
+export declare const makeLocalPreviewError: (error: LocalPreviewError) => LocalPreviewError;
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAEhC,eAAO,MAAM,eAAe,6OAWjB,CAAC;AAEZ,MAAM,MAAM,SAAS,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,eAAe,CAAC,CAAC;AAEnE,eAAO,MAAM,uBAAuB;;;;;;EAMlC,CAAC;AAEH,MAAM,MAAM,iBAAiB,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAEnF,eAAO,MAAM,qBAAqB,GAAI,OAAO,iBAAiB,KAAG,iBAA0B,CAAC"}

package/dist/errors.js

@@ -0,0 +1,21 @@
+import { Schema } from "effect";
+export const ErrorCodeSchema = Schema.Literals([
+    "BODY_TOO_LARGE",
+    "INVALID_SUBDOMAIN",
+    "REQUEST_TIMEOUT",
+    "REQUEST_FAILED",
+    "RELAY_REGISTRATION_FAILED",
+    "SANDBOX_CREATE_FAILED",
+    "SUBDOMAIN_TAKEN",
+    "TUNNEL_NOT_CONNECTED",
+    "TUNNEL_NOT_FOUND",
+    "UNAUTHORIZED",
+]);
+export const LocalPreviewErrorSchema = Schema.Struct({
+    code: ErrorCodeSchema,
+    message: Schema.String,
+    requestId: Schema.optional(Schema.String),
+    subdomain: Schema.optional(Schema.String),
+    limitBytes: Schema.optional(Schema.Number),
+});
+export const makeLocalPreviewError = (error) => error;

package/dist/headers.d.ts

@@ -0,0 +1,19 @@
+export declare const LOCALPREVIEW_ADMIN_TOKEN_HEADER = "x-localpreview-admin-token";
+export declare const LOCALPREVIEW_FORWARDED_HOST_HEADER = "x-localpreview-forwarded-host";
+export declare const LOCALPREVIEW_FORWARDED_PROTO_HEADER = "x-localpreview-forwarded-proto";
+export declare const LOCALPREVIEW_PROXY_TOKEN_HEADER = "x-localpreview-proxy-token";
+export type HeaderMap = Readonly<Record<string, string>>;
+export type HeaderPair = readonly [name: string, value: string];
+export type HeaderPairs = ReadonlyArray<HeaderPair>;
+export declare const isHopByHopHeader: (name: string) => boolean;
+export declare const isInternalLocalPreviewHeader: (name: string) => boolean;
+export declare const filterEndToEndHeaders: (headers: HeaderMap) => HeaderMap;
+export declare const filterInternalLocalPreviewHeaders: (headers: HeaderMap) => HeaderMap;
+export declare const filterEndToEndHeaderPairs: (headers: HeaderPairs) => HeaderPairs;
+export declare const filterInternalLocalPreviewHeaderPairs: (headers: HeaderPairs) => HeaderPairs;
+export declare const headerPairsToMap: (headers: HeaderPairs) => HeaderMap;
+export declare const headerMapToPairs: (headers: HeaderMap) => HeaderPairs;
+export declare const flattenHeaderPairs: (headers: HeaderPairs) => Array<string>;
+export declare const headersToMap: (headers: Headers) => HeaderMap;
+export declare const recordToHeaders: (headers: HeaderMap) => Headers;
+//# sourceMappingURL=headers.d.ts.map

package/dist/headers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"headers.d.ts","sourceRoot":"","sources":["../src/headers.ts"],"names":[],"mappings":"AAWA,eAAO,MAAM,+BAA+B,+BAA+B,CAAC;AAC5E,eAAO,MAAM,kCAAkC,kCAAkC,CAAC;AAClF,eAAO,MAAM,mCAAmC,mCAAmC,CAAC;AACpF,eAAO,MAAM,+BAA+B,+BAA+B,CAAC;AAS5E,MAAM,MAAM,SAAS,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;AACzD,MAAM,MAAM,UAAU,GAAG,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,CAAC,CAAC;AAChE,MAAM,MAAM,WAAW,GAAG,aAAa,CAAC,UAAU,CAAC,CAAC;AAEpD,eAAO,MAAM,gBAAgB,GAAI,MAAM,MAAM,KAAG,OAAkD,CAAC;AAEnG,eAAO,MAAM,4BAA4B,GAAI,MAAM,MAAM,KAAG,OACP,CAAC;AAEtD,eAAO,MAAM,qBAAqB,GAAI,SAAS,SAAS,KAAG,SAC8B,CAAC;AAE1F,eAAO,MAAM,iCAAiC,GAAI,SAAS,SAAS,KAAG,SAGpE,CAAC;AAEJ,eAAO,MAAM,yBAAyB,GAAI,SAAS,WAAW,KAAG,WACZ,CAAC;AAEtD,eAAO,MAAM,qCAAqC,GAAI,SAAS,WAAW,KAAG,WACZ,CAAC;AAElE,eAAO,MAAM,gBAAgB,GAAI,SAAS,WAAW,KAAG,SAAwC,CAAC;AAEjG,eAAO,MAAM,gBAAgB,GAAI,SAAS,SAAS,KAAG,WAAsC,CAAC;AAE7F,eAAO,MAAM,kBAAkB,GAAI,SAAS,WAAW,KAAG,KAAK,CAAC,MAAM,CACnB,CAAC;AAEpD,eAAO,MAAM,YAAY,GAAI,SAAS,OAAO,KAAG,SAAkD,CAAC;AAEnG,eAAO,MAAM,eAAe,GAAI,SAAS,SAAS,KAAG,OAQpD,CAAC"}

package/dist/headers.js

@@ -0,0 +1,37 @@
+const hopByHopHeaders = new Set([
+    "connection",
+    "keep-alive",
+    "proxy-authenticate",
+    "proxy-authorization",
+    "te",
+    "trailer",
+    "transfer-encoding",
+    "upgrade",
+]);
+export const LOCALPREVIEW_ADMIN_TOKEN_HEADER = "x-localpreview-admin-token";
+export const LOCALPREVIEW_FORWARDED_HOST_HEADER = "x-localpreview-forwarded-host";
+export const LOCALPREVIEW_FORWARDED_PROTO_HEADER = "x-localpreview-forwarded-proto";
+export const LOCALPREVIEW_PROXY_TOKEN_HEADER = "x-localpreview-proxy-token";
+const internalLocalPreviewHeaders = new Set([
+    LOCALPREVIEW_ADMIN_TOKEN_HEADER,
+    LOCALPREVIEW_FORWARDED_HOST_HEADER,
+    LOCALPREVIEW_FORWARDED_PROTO_HEADER,
+    LOCALPREVIEW_PROXY_TOKEN_HEADER,
+]);
+export const isHopByHopHeader = (name) => hopByHopHeaders.has(name.toLowerCase());
+export const isInternalLocalPreviewHeader = (name) => internalLocalPreviewHeaders.has(name.toLowerCase());
+export const filterEndToEndHeaders = (headers) => Object.fromEntries(Object.entries(headers).filter(([name]) => !isHopByHopHeader(name)));
+export const filterInternalLocalPreviewHeaders = (headers) => Object.fromEntries(Object.entries(headers).filter(([name]) => !isInternalLocalPreviewHeader(name)));
+export const filterEndToEndHeaderPairs = (headers) => headers.filter(([name]) => !isHopByHopHeader(name));
+export const filterInternalLocalPreviewHeaderPairs = (headers) => headers.filter(([name]) => !isInternalLocalPreviewHeader(name));
+export const headerPairsToMap = (headers) => Object.fromEntries(headers);
+export const headerMapToPairs = (headers) => Object.entries(headers);
+export const flattenHeaderPairs = (headers) => headers.flatMap(([name, value]) => [name, value]);
+export const headersToMap = (headers) => Object.fromEntries(headers.entries());
+export const recordToHeaders = (headers) => {
+    const result = new Headers();
+    for (const [name, value] of Object.entries(headers)) {
+        result.set(name, value);
+    }
+    return result;
+};

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export * from "./errors.js";
+export * from "./headers.js";
+export * from "./messages.js";
+export * from "./public-domain.js";
+export * from "./subdomain.js";
+export * from "./target.js";
+export * from "./tunnel.js";
+export * from "./version.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,cAAc,CAAC;AAC7B,cAAc,eAAe,CAAC;AAC9B,cAAc,oBAAoB,CAAC;AACnC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,cAAc,CAAC"}

package/dist/index.js

@@ -0,0 +1,8 @@
+export * from "./errors.js";
+export * from "./headers.js";
+export * from "./messages.js";
+export * from "./public-domain.js";
+export * from "./subdomain.js";
+export * from "./target.js";
+export * from "./tunnel.js";
+export * from "./version.js";

package/dist/messages.d.ts

@@ -0,0 +1,159 @@
+import { Schema } from "effect";
+import type { HeaderPairs } from "./headers.js";
+export declare const RequestIdSchema: Schema.String;
+export type RequestId = Schema.Schema.Type<typeof RequestIdSchema>;
+export declare const RequestStartMessageSchema: Schema.Struct<{
+    readonly headers: Schema.$Array<Schema.Tuple<readonly [Schema.String, Schema.String]>>;
+    readonly method: Schema.String;
+    readonly path: Schema.String;
+    readonly requestId: Schema.String;
+    readonly type: Schema.Literal<"request-start">;
+}>;
+export declare const RequestChunkMessageSchema: Schema.Struct<{
+    readonly chunkBase64: Schema.String;
+    readonly requestId: Schema.String;
+    readonly type: Schema.Literal<"request-chunk">;
+}>;
+export declare const RequestEndMessageSchema: Schema.Struct<{
+    readonly requestId: Schema.String;
+    readonly type: Schema.Literal<"request-end">;
+}>;
+export declare const CancelMessageSchema: Schema.Struct<{
+    readonly requestId: Schema.String;
+    readonly type: Schema.Literal<"cancel">;
+}>;
+export declare const ResponseStartMessageSchema: Schema.Struct<{
+    readonly headers: Schema.$Array<Schema.Tuple<readonly [Schema.String, Schema.String]>>;
+    readonly requestId: Schema.String;
+    readonly status: Schema.Number;
+    readonly type: Schema.Literal<"response-start">;
+}>;
+export declare const ResponseChunkMessageSchema: Schema.Struct<{
+    readonly chunkBase64: Schema.String;
+    readonly requestId: Schema.String;
+    readonly type: Schema.Literal<"response-chunk">;
+}>;
+export declare const ResponseEndMessageSchema: Schema.Struct<{
+    readonly requestId: Schema.String;
+    readonly type: Schema.Literal<"response-end">;
+}>;
+export declare const ResponseErrorMessageSchema: Schema.Struct<{
+    readonly message: Schema.String;
+    readonly requestId: Schema.String;
+    readonly type: Schema.Literal<"response-error">;
+}>;
+export declare const ServerMessageSchema: Schema.Union<readonly [Schema.Struct<{
+    readonly headers: Schema.$Array<Schema.Tuple<readonly [Schema.String, Schema.String]>>;
+    readonly method: Schema.String;
+    readonly path: Schema.String;
+    readonly requestId: Schema.String;
+    readonly type: Schema.Literal<"request-start">;
+}>, Schema.Struct<{
+    readonly chunkBase64: Schema.String;
+    readonly requestId: Schema.String;
+    readonly type: Schema.Literal<"request-chunk">;
+}>, Schema.Struct<{
+    readonly requestId: Schema.String;
+    readonly type: Schema.Literal<"request-end">;
+}>, Schema.Struct<{
+    readonly requestId: Schema.String;
+    readonly type: Schema.Literal<"cancel">;
+}>]>;
+export declare const ClientMessageSchema: Schema.Union<readonly [Schema.Struct<{
+    readonly headers: Schema.$Array<Schema.Tuple<readonly [Schema.String, Schema.String]>>;
+    readonly requestId: Schema.String;
+    readonly status: Schema.Number;
+    readonly type: Schema.Literal<"response-start">;
+}>, Schema.Struct<{
+    readonly chunkBase64: Schema.String;
+    readonly requestId: Schema.String;
+    readonly type: Schema.Literal<"response-chunk">;
+}>, Schema.Struct<{
+    readonly requestId: Schema.String;
+    readonly type: Schema.Literal<"response-end">;
+}>, Schema.Struct<{
+    readonly message: Schema.String;
+    readonly requestId: Schema.String;
+    readonly type: Schema.Literal<"response-error">;
+}>]>;
+export declare const RelayMessageSchema: Schema.Union<readonly [Schema.Union<readonly [Schema.Struct<{
+    readonly headers: Schema.$Array<Schema.Tuple<readonly [Schema.String, Schema.String]>>;
+    readonly method: Schema.String;
+    readonly path: Schema.String;
+    readonly requestId: Schema.String;
+    readonly type: Schema.Literal<"request-start">;
+}>, Schema.Struct<{
+    readonly chunkBase64: Schema.String;
+    readonly requestId: Schema.String;
+    readonly type: Schema.Literal<"request-chunk">;
+}>, Schema.Struct<{
+    readonly requestId: Schema.String;
+    readonly type: Schema.Literal<"request-end">;
+}>, Schema.Struct<{
+    readonly requestId: Schema.String;
+    readonly type: Schema.Literal<"cancel">;
+}>]>, Schema.Union<readonly [Schema.Struct<{
+    readonly headers: Schema.$Array<Schema.Tuple<readonly [Schema.String, Schema.String]>>;
+    readonly requestId: Schema.String;
+    readonly status: Schema.Number;
+    readonly type: Schema.Literal<"response-start">;
+}>, Schema.Struct<{
+    readonly chunkBase64: Schema.String;
+    readonly requestId: Schema.String;
+    readonly type: Schema.Literal<"response-chunk">;
+}>, Schema.Struct<{
+    readonly requestId: Schema.String;
+    readonly type: Schema.Literal<"response-end">;
+}>, Schema.Struct<{
+    readonly message: Schema.String;
+    readonly requestId: Schema.String;
+    readonly type: Schema.Literal<"response-error">;
+}>]>]>;
+export type ServerMessage = {
+    readonly type: "request-start";
+    readonly requestId: RequestId;
+    readonly method: string;
+    readonly path: string;
+    readonly headers: HeaderPairs;
+} | {
+    readonly type: "request-chunk";
+    readonly requestId: RequestId;
+    readonly chunkBase64: string;
+} | {
+    readonly type: "request-end";
+    readonly requestId: RequestId;
+} | {
+    readonly type: "cancel";
+    readonly requestId: RequestId;
+};
+export type ClientMessage = {
+    readonly type: "response-start";
+    readonly requestId: RequestId;
+    readonly status: number;
+    readonly headers: HeaderPairs;
+} | {
+    readonly type: "response-chunk";
+    readonly requestId: RequestId;
+    readonly chunkBase64: string;
+} | {
+    readonly type: "response-end";
+    readonly requestId: RequestId;
+} | {
+    readonly type: "response-error";
+    readonly requestId: RequestId;
+    readonly message: string;
+};
+export type RelayMessage = ServerMessage | ClientMessage;
+export declare const encodeRelayMessage: (message: RelayMessage) => string;
+export declare const decodeRelayMessage: (input: string) => RelayMessage;
+export type RelayMessageDecodeResult<A> = {
+    readonly ok: true;
+    readonly message: A;
+} | {
+    readonly error: unknown;
+    readonly ok: false;
+};
+export declare const decodeServerRelayMessage: (input: string) => RelayMessageDecodeResult<ServerMessage>;
+export declare const decodeClientRelayMessage: (input: string) => RelayMessageDecodeResult<ClientMessage>;
+export declare const decodeTypedRelayMessage: (input: string) => RelayMessageDecodeResult<RelayMessage>;
+//# sourceMappingURL=messages.d.ts.map

package/dist/messages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"messages.d.ts","sourceRoot":"","sources":["../src/messages.ts"],"names":[],"mappings":"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"}

package/dist/messages.js

@@ -0,0 +1,73 @@
+import { Result, Schema } from "effect";
+export const RequestIdSchema = Schema.String;
+const HeaderPairsSchema = Schema.Array(Schema.Tuple([Schema.String, Schema.String]));
+export const RequestStartMessageSchema = Schema.Struct({
+    headers: HeaderPairsSchema,
+    method: Schema.String,
+    path: Schema.String,
+    requestId: RequestIdSchema,
+    type: Schema.Literal("request-start"),
+});
+export const RequestChunkMessageSchema = Schema.Struct({
+    chunkBase64: Schema.String,
+    requestId: RequestIdSchema,
+    type: Schema.Literal("request-chunk"),
+});
+export const RequestEndMessageSchema = Schema.Struct({
+    requestId: RequestIdSchema,
+    type: Schema.Literal("request-end"),
+});
+export const CancelMessageSchema = Schema.Struct({
+    requestId: RequestIdSchema,
+    type: Schema.Literal("cancel"),
+});
+export const ResponseStartMessageSchema = Schema.Struct({
+    headers: HeaderPairsSchema,
+    requestId: RequestIdSchema,
+    status: Schema.Number,
+    type: Schema.Literal("response-start"),
+});
+export const ResponseChunkMessageSchema = Schema.Struct({
+    chunkBase64: Schema.String,
+    requestId: RequestIdSchema,
+    type: Schema.Literal("response-chunk"),
+});
+export const ResponseEndMessageSchema = Schema.Struct({
+    requestId: RequestIdSchema,
+    type: Schema.Literal("response-end"),
+});
+export const ResponseErrorMessageSchema = Schema.Struct({
+    message: Schema.String,
+    requestId: RequestIdSchema,
+    type: Schema.Literal("response-error"),
+});
+export const ServerMessageSchema = Schema.Union([
+    RequestStartMessageSchema,
+    RequestChunkMessageSchema,
+    RequestEndMessageSchema,
+    CancelMessageSchema,
+]);
+export const ClientMessageSchema = Schema.Union([
+    ResponseStartMessageSchema,
+    ResponseChunkMessageSchema,
+    ResponseEndMessageSchema,
+    ResponseErrorMessageSchema,
+]);
+export const RelayMessageSchema = Schema.Union([ServerMessageSchema, ClientMessageSchema]);
+export const encodeRelayMessage = (message) => JSON.stringify(message);
+export const decodeRelayMessage = (input) => JSON.parse(input);
+export const decodeServerRelayMessage = (input) => decodeWithSchema(input, ServerMessageSchema);
+export const decodeClientRelayMessage = (input) => decodeWithSchema(input, ClientMessageSchema);
+export const decodeTypedRelayMessage = (input) => decodeWithSchema(input, RelayMessageSchema);
+const decodeWithSchema = (input, schema) => {
+    try {
+        const result = Schema.decodeUnknownResult(schema)(JSON.parse(input));
+        if (Result.isSuccess(result)) {
+            return { message: result.success, ok: true };
+        }
+        return { error: result.failure, ok: false };
+    }
+    catch (error) {
+        return { error, ok: false };
+    }
+};

package/dist/public-domain.d.ts

@@ -0,0 +1,3 @@
+export declare const LOCALPREVIEW_PUBLIC_DOMAIN = "localpreview.dev";
+export declare const LOCALPREVIEW_PUBLIC_ORIGIN = "https://localpreview.dev";
+//# sourceMappingURL=public-domain.d.ts.map

package/dist/public-domain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"public-domain.d.ts","sourceRoot":"","sources":["../src/public-domain.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,0BAA0B,qBAAqB,CAAC;AAC7D,eAAO,MAAM,0BAA0B,6BAA0C,CAAC"}

package/dist/public-domain.js

@@ -0,0 +1,2 @@
+export const LOCALPREVIEW_PUBLIC_DOMAIN = "localpreview.dev";
+export const LOCALPREVIEW_PUBLIC_ORIGIN = `https://${LOCALPREVIEW_PUBLIC_DOMAIN}`;

package/dist/subdomain.d.ts

@@ -0,0 +1,9 @@
+export type SubdomainValidationResult = {
+    readonly valid: true;
+    readonly subdomain: string;
+} | {
+    readonly valid: false;
+    readonly reason: "invalid-format" | "reserved";
+};
+export declare const validateRequestedSubdomain: (input: string) => SubdomainValidationResult;
+//# sourceMappingURL=subdomain.d.ts.map

package/dist/subdomain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subdomain.d.ts","sourceRoot":"","sources":["../src/subdomain.ts"],"names":[],"mappings":"AAaA,MAAM,MAAM,yBAAyB,GACjC;IACE,QAAQ,CAAC,KAAK,EAAE,IAAI,CAAC;IACrB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC5B,GACD;IACE,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,gBAAgB,GAAG,UAAU,CAAC;CAChD,CAAC;AAEN,eAAO,MAAM,0BAA0B,GAAI,OAAO,MAAM,KAAG,yBAY1D,CAAC"}

package/dist/subdomain.js

@@ -0,0 +1,22 @@
+const reservedSubdomains = new Set([
+    "admin",
+    "api",
+    "app",
+    "assets",
+    "auth",
+    "dashboard",
+    "login",
+    "static",
+    "status",
+    "www",
+]);
+export const validateRequestedSubdomain = (input) => {
+    const subdomain = input.trim().toLowerCase();
+    if (reservedSubdomains.has(subdomain)) {
+        return { valid: false, reason: "reserved" };
+    }
+    if (!/^[a-z0-9](?:[a-z0-9-]{1,30}[a-z0-9])$/.test(subdomain)) {
+        return { valid: false, reason: "invalid-format" };
+    }
+    return { valid: true, subdomain };
+};

package/dist/target.d.ts

@@ -0,0 +1,14 @@
+export type TunnelTarget = {
+    readonly protocol: "http" | "https";
+    readonly hostname: string;
+    readonly port: number;
+};
+export type ParseTargetResult = {
+    readonly ok: true;
+    readonly target: TunnelTarget;
+} | {
+    readonly ok: false;
+    readonly message: string;
+};
+export declare const parseTarget: (input: string) => ParseTargetResult;
+//# sourceMappingURL=target.d.ts.map

package/dist/target.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"target.d.ts","sourceRoot":"","sources":["../src/target.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,YAAY,GAAG;IACzB,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC;IACpC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB,CAAC;AAEF,MAAM,MAAM,iBAAiB,GACzB;IACE,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC;IAClB,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAC;CAC/B,GACD;IACE,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC;IACnB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B,CAAC;AAEN,eAAO,MAAM,WAAW,GAAI,OAAO,MAAM,KAAG,iBA4B3C,CAAC"}

package/dist/target.js

@@ -0,0 +1,46 @@
+export const parseTarget = (input) => {
+    const trimmed = input.trim();
+    if (/^\d+$/.test(trimmed)) {
+        return makeTarget("http", "127.0.0.1", Number(trimmed));
+    }
+    const withProtocol = trimmed.includes("://") ? trimmed : `http://${trimmed}`;
+    try {
+        const url = new URL(withProtocol);
+        const protocol = parseProtocol(url.protocol);
+        if (protocol === undefined) {
+            return { ok: false, message: "Target protocol must be http or https." };
+        }
+        if (url.port === "") {
+            return { ok: false, message: "Target must include a port." };
+        }
+        return makeTarget(protocol, url.hostname, Number(url.port));
+    }
+    catch {
+        return {
+            ok: false,
+            message: "Target must be a port or URL, like 4000 or https://localhost:4000.",
+        };
+    }
+};
+const parseProtocol = (protocol) => {
+    if (protocol === "http:") {
+        return "http";
+    }
+    if (protocol === "https:") {
+        return "https";
+    }
+    return undefined;
+};
+const makeTarget = (protocol, hostname, port) => {
+    if (!Number.isInteger(port) || port < 1 || port > 65_535) {
+        return { ok: false, message: "Target port must be between 1 and 65535." };
+    }
+    return {
+        ok: true,
+        target: {
+            hostname,
+            port,
+            protocol,
+        },
+    };
+};

package/dist/tunnel.d.ts

@@ -0,0 +1,34 @@
+import { Schema } from "effect";
+export declare const TunnelStatusSchema: Schema.Literals<readonly ["starting", "connected", "disconnected", "expired"]>;
+export type TunnelStatus = Schema.Schema.Type<typeof TunnelStatusSchema>;
+export type TunnelRecord = {
+    readonly tunnelId: string;
+    readonly subdomain: string;
+    readonly relayHttpUrl: string;
+    readonly relayWsUrl: string;
+    readonly proxyToken: string;
+    readonly relayProvider?: "local" | "vercel";
+    readonly status: TunnelStatus;
+    readonly sandboxId?: string;
+    readonly createdAt: string;
+    readonly expiresAt: string;
+};
+export type CreateTunnelRequest = {
+    readonly requestedSubdomain?: string;
+};
+export type CreateTunnelResponse = {
+    readonly tunnelId: string;
+    readonly subdomain: string;
+    readonly publicUrl: string;
+    readonly relayWsUrl: string;
+    readonly clientToken: string;
+    readonly expiresAt: string;
+    readonly protocolVersion: string;
+    readonly relaySnapshotVersion: string;
+};
+export type RegisterRelayTunnelRequest = {
+    readonly tunnelId: string;
+    readonly clientToken: string;
+    readonly proxyToken: string;
+};
+//# sourceMappingURL=tunnel.d.ts.map

package/dist/tunnel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tunnel.d.ts","sourceRoot":"","sources":["../src/tunnel.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAEhC,eAAO,MAAM,kBAAkB,gFAKpB,CAAC;AAEZ,MAAM,MAAM,YAAY,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAEzE,MAAM,MAAM,YAAY,GAAG;IACzB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,aAAa,CAAC,EAAE,OAAO,GAAG,QAAQ,CAAC;IAC5C,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAC;IAC9B,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC5B,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAChC,QAAQ,CAAC,kBAAkB,CAAC,EAAE,MAAM,CAAC;CACtC,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG;IACjC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,oBAAoB,EAAE,MAAM,CAAC;CACvC,CAAC;AAEF,MAAM,MAAM,0BAA0B,GAAG;IACvC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B,CAAC"}

package/dist/tunnel.js

@@ -0,0 +1,7 @@
+import { Schema } from "effect";
+export const TunnelStatusSchema = Schema.Literals([
+    "starting",
+    "connected",
+    "disconnected",
+    "expired",
+]);

package/dist/version.d.ts

@@ -0,0 +1,20 @@
+import { Schema } from "effect";
+export declare const LOCALPREVIEW_PROTOCOL_VERSION = "1";
+export declare const LOCALPREVIEW_RELAY_SNAPSHOT_VERSION = "2026-05-25.1";
+export declare const RelayHealthResponseSchema: Schema.Struct<{
+    readonly ok: Schema.Literal<true>;
+    readonly protocolVersion: Schema.String;
+    readonly relaySnapshotVersion: Schema.String;
+    readonly service: Schema.String;
+    readonly tunnels: Schema.Number;
+}>;
+export type RelayHealthResponse = Schema.Schema.Type<typeof RelayHealthResponseSchema>;
+export type RelayHealthDecodeResult = {
+    readonly health: RelayHealthResponse;
+    readonly ok: true;
+} | {
+    readonly error: unknown;
+    readonly ok: false;
+};
+export declare const decodeRelayHealthResponse: (input: unknown) => RelayHealthDecodeResult;
+//# sourceMappingURL=version.d.ts.map

package/dist/version.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../src/version.ts"],"names":[],"mappings":"AAAA,OAAO,EAAU,MAAM,EAAE,MAAM,QAAQ,CAAC;AAExC,eAAO,MAAM,6BAA6B,MAAM,CAAC;AACjD,eAAO,MAAM,mCAAmC,iBAAiB,CAAC;AAElE,eAAO,MAAM,yBAAyB;;;;;;EAMpC,CAAC;AAEH,MAAM,MAAM,mBAAmB,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAEvF,MAAM,MAAM,uBAAuB,GAC/B;IACE,QAAQ,CAAC,MAAM,EAAE,mBAAmB,CAAC;IACrC,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC;CACnB,GACD;IACE,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC;CACpB,CAAC;AAEN,eAAO,MAAM,yBAAyB,GAAI,OAAO,OAAO,KAAG,uBAQ1D,CAAC"}

package/dist/version.js

@@ -0,0 +1,17 @@
+import { Result, Schema } from "effect";
+export const LOCALPREVIEW_PROTOCOL_VERSION = "1";
+export const LOCALPREVIEW_RELAY_SNAPSHOT_VERSION = "2026-05-25.1";
+export const RelayHealthResponseSchema = Schema.Struct({
+    ok: Schema.Literal(true),
+    protocolVersion: Schema.String,
+    relaySnapshotVersion: Schema.String,
+    service: Schema.String,
+    tunnels: Schema.Number,
+});
+export const decodeRelayHealthResponse = (input) => {
+    const result = Schema.decodeUnknownResult(RelayHealthResponseSchema)(input);
+    if (Result.isSuccess(result)) {
+        return { health: result.success, ok: true };
+    }
+    return { error: result.failure, ok: false };
+};

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@localpreview/protocol",
+  "version": "0.1.0",
+  "type": "module",
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "types": "./dist/index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "effect": "beta"
+  },
+  "devDependencies": {
+    "typescript": "latest",
+    "vitest": "latest"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "dev": "tsc -p tsconfig.build.json --watch",
+    "lint": "oxlint .",
+    "test": "vitest run",
+    "typecheck": "tsc -p tsconfig.json --noEmit"
+  }
+}