@milaboratories/pl-model-common 1.26.1 → 1.28.0

package/dist/drivers/pspec.d.ts

@@ -0,0 +1,137 @@
+import { AxisSpec, PColumnIdAndSpec, PColumnSpec, ValueType } from "./pframe/spec/spec.js";
+import { SingleAxisSelector } from "./pframe/spec/selectors.js";
+import "./pframe/index.js";
+import { Branded } from "@milaboratories/helpers";
+
+//#region src/drivers/pspec.d.ts
+/** Matches a string value either exactly or by regex pattern */
+type StringMatcher = {
+  type: "exact";
+  value: string;
+} | {
+  type: "regex";
+  value: string;
+};
+/** Map of key to array of string matchers (OR-ed per key, AND-ed across keys) */
+type MatcherMap = Record<string, StringMatcher[]>;
+/** Selector for matching axes by various criteria */
+interface MultiAxisSelector {
+  /** Match any of the axis types listed here */
+  readonly type?: ValueType[];
+  /** Match any of the axis names listed here */
+  readonly name?: StringMatcher[];
+  /** Match requires all the domains listed here */
+  readonly domain?: MatcherMap;
+  /** Match requires all the context domains listed here */
+  readonly contextDomain?: MatcherMap;
+  /** Match requires all the annotations listed here */
+  readonly annotations?: MatcherMap;
+}
+/** Column selector for discover columns request, matching columns by various criteria.
+ * Multiple selectors are OR-ed: a column matches if it satisfies any selector. */
+interface MultiColumnSelector {
+  /** Match any of the value types listed here */
+  readonly type?: ValueType[];
+  /** Match any of the names listed here */
+  readonly name?: StringMatcher[];
+  /** Match requires all the domains listed here */
+  readonly domain?: MatcherMap;
+  /** Match requires all the context domains listed here */
+  readonly contextDomain?: MatcherMap;
+  /** Match requires all the annotations listed here */
+  readonly annotations?: MatcherMap;
+  /** Match any of the axis selectors listed here */
+  readonly axes?: MultiAxisSelector[];
+  /** When true (default), allows matching if only a subset of axes match */
+  readonly partialAxesMatch?: boolean;
+}
+/** Qualification applied to a single axis to make it compatible during integration. */
+interface AxisQualification {
+  /** Axis selector identifying which axis is qualified. */
+  readonly axis: SingleAxisSelector;
+  /** Additional context domain entries applied to the axis. */
+  readonly contextDomain: Record<string, string>;
+}
+/** Qualifications needed for both query (already-integrated) columns and the hit column. */
+interface ColumnAxesWithQualifications {
+  /** Already integrated (query) columns with their qualifications. */
+  axesSpec: AxisSpec[];
+  /** Qualifications for each already integrated (query) column. */
+  qualifications: AxisQualification[];
+}
+/** Fine-grained constraints controlling axes matching and qualification behavior */
+interface DiscoverColumnsConstraints {
+  /** Allow source (query) axes that have no match in the hit column */
+  allowFloatingSourceAxes: boolean;
+  /** Allow hit column axes that have no match in the source (query) */
+  allowFloatingHitAxes: boolean;
+  /** Allow source (query) axes to be qualified (contextDomain extended) */
+  allowSourceQualifications: boolean;
+  /** Allow hit column axes to be qualified (contextDomain extended) */
+  allowHitQualifications: boolean;
+}
+/** Request for discovering columns compatible with a given axes integration */
+interface DiscoverColumnsRequest {
+  /** Column filters (OR-ed); empty array matches all columns */
+  columnFilter?: MultiColumnSelector[];
+  /** Already integrated axes with qualifications */
+  axes: ColumnAxesWithQualifications[];
+  /** Constraints controlling axes matching and qualification behavior */
+  constraints: DiscoverColumnsConstraints;
+}
+/** Linker step: traversal through a linker column */
+interface DiscoverColumnsLinkerStep {
+  type: "linker";
+  /** The linker column traversed in this step */
+  linker: PColumnIdAndSpec;
+  /** Axis qualifications produced when matching the linker's many-side axes */
+  qualifications: AxisQualification[];
+}
+/** A step traversed during path-based column discovery. Discriminated by `type`. */
+type DiscoverColumnsStepInfo = DiscoverColumnsLinkerStep;
+/** Qualifications info for a discover columns response mapping variant */
+interface DiscoverColumnsResponseQualifications {
+  /** Qualifications for each query (already-integrated) column set */
+  forQueries: AxisQualification[][];
+  /** Qualifications for the hit column */
+  forHit: AxisQualification[];
+}
+/** A single mapping variant describing how a hit column can be integrated */
+interface DiscoverColumnsMappingVariant {
+  /** Full qualifications needed for integration */
+  qualifications: DiscoverColumnsResponseQualifications;
+  /** Distinctive (minimal) qualifications needed for integration */
+  distinctiveQualifications: DiscoverColumnsResponseQualifications;
+}
+/** A single hit in the discover columns response */
+interface DiscoverColumnsResponseHit {
+  /** The column that was found compatible */
+  hit: PColumnIdAndSpec;
+  /** Possible ways to integrate this column with the existing set */
+  mappingVariants: DiscoverColumnsMappingVariant[];
+}
+/** Response from discover columns */
+interface DiscoverColumnsResponse {
+  /** Columns that could be integrated and possible ways to integrate them */
+  hits: DiscoverColumnsResponseHit[];
+}
+/** Handle to a spec-only PFrame (no data, synchronous operations). */
+type SpecFrameHandle = Branded<string, "SpecFrameHandle">;
+/**
+ * Synchronous driver for spec-level PFrame operations.
+ *
+ * Unlike the async PFrameDriver (which works with data), this driver
+ * operates on column specifications only. All methods are synchronous
+ * because the underlying WASM PFrame computes results immediately.
+ */
+interface PSpecDriver {
+  /** Create a spec-only PFrame from column specs. Returns a handle. */
+  createSpecFrame(specs: Record<string, PColumnSpec>): SpecFrameHandle;
+  /** Discover columns compatible with given axes integration. */
+  specFrameDiscoverColumns(handle: SpecFrameHandle, request: DiscoverColumnsRequest): DiscoverColumnsResponse;
+  /** Dispose a spec frame, freeing WASM resources. */
+  disposeSpecFrame(handle: SpecFrameHandle): void;
+}
+//#endregion
+export { AxisQualification, ColumnAxesWithQualifications, DiscoverColumnsConstraints, DiscoverColumnsLinkerStep, DiscoverColumnsMappingVariant, DiscoverColumnsRequest, DiscoverColumnsResponse, DiscoverColumnsResponseHit, DiscoverColumnsResponseQualifications, DiscoverColumnsStepInfo, MatcherMap, MultiAxisSelector, MultiColumnSelector, PSpecDriver, SpecFrameHandle, StringMatcher };
+//# sourceMappingURL=pspec.d.ts.map

package/dist/index.cjs

@@ -34,6 +34,7 @@ const require_ref = require('./ref.cjs');
 const require_value_or_error = require('./value_or_error.cjs');
 const require_base64 = require('./base64.cjs');
 const require_httpAuth = require('./httpAuth.cjs');
+const require_resource_types = require('./resource_types.cjs');
 
 exports.AbortError = require_errors.AbortError;
 exports.AllRequiresFeatureFlags = require_block_flags.AllRequiresFeatureFlags;
@@ -59,6 +60,8 @@ exports.PlIdBytes = require_plid.PlIdBytes;
 exports.PlIdLength = require_plid.PlIdLength;
 exports.PlRef = require_ref.PlRef;
 exports.RangeBytes = require_blob.RangeBytes;
+exports.ResourceTypeName = require_resource_types.ResourceTypeName;
+exports.ResourceTypePrefix = require_resource_types.ResourceTypePrefix;
 exports.RuntimeCapabilities = require_flag_utils.RuntimeCapabilities;
 exports.UiError = require_errors.UiError;
 exports.ValueType = require_spec.ValueType;
@@ -126,6 +129,7 @@ exports.isPTableNA = require_data_types.isPTableNA;
 exports.isPTableValueAxis = require_data_types.isPTableValueAxis;
 exports.isPartitionedDataInfoEntries = require_data_info.isPartitionedDataInfoEntries;
 exports.isPlRef = require_ref.isPlRef;
+exports.legacyColumnSelectorsToPredicate = require_selectors.legacyColumnSelectorsToPredicate;
 exports.mapDataInfo = require_data_info.mapDataInfo;
 exports.mapDataInfoEntries = require_data_info.mapDataInfoEntries;
 exports.mapJoinEntry = require_table_calculate.mapJoinEntry;
@@ -155,7 +159,6 @@ exports.readMetadata = require_spec.readMetadata;
 exports.readMetadataJson = require_spec.readMetadataJson;
 exports.readMetadataJsonOrThrow = require_spec.readMetadataJsonOrThrow;
 exports.resolveAnchors = require_anchored.resolveAnchors;
-exports.selectorsToPredicate = require_selectors.selectorsToPredicate;
 exports.serializeError = require_errors.serializeError;
 exports.serializeHttpAuth = require_httpAuth.serializeHttpAuth;
 exports.serializeResult = require_errors.serializeResult;

package/dist/index.d.ts

@@ -26,7 +26,7 @@ import "./pool/index.js";
 import { Annotation, AnnotationJson, AxesId, AxesSpec, AxisId, AxisSpec, AxisSpecNormalized, AxisTree, AxisValueType, ColumnValueType, Domain, DomainJson, Metadata, MetadataJson, PAxisName, PColumn, PColumnIdAndSpec, PColumnInfo, PColumnLazy, PColumnName, PColumnSpec, PColumnSpecId, PDataColumnSpec, PUniversalColumnSpec, ValueType, canonicalizeAxisId, canonicalizeAxisWithParents, getArrayFromAxisTree, getAxesId, getAxesTree, getAxisId, getColumnIdAndSpec, getDenormalizedAxesList, getNormalizedAxesList, getPColumnSpecId, getSetFromAxisTree, getTypeFromPColumnOrAxisSpec, isAxisId, isLabelColumn, isLinkerColumn, matchAxisId, readAnnotation, readAnnotationJson, readAnnotationJsonOrThrow, readDomain, readDomainJson, readDomainJsonOrThrow, readMetadata, readMetadataJson, readMetadataJsonOrThrow } from "./drivers/pframe/spec/spec.js";
 import { ColumnFilter } from "./drivers/pframe/column_filter.js";
 import { BinaryChunk, BinaryPartitionedDataInfo, BinaryPartitionedDataInfoEntries, DataInfo, DataInfoEntries, JsonDataInfo, JsonDataInfoEntries, JsonPartitionedDataInfo, JsonPartitionedDataInfoEntries, PColumnDataEntry, PColumnKey, PColumnValue, PColumnValues, PColumnValuesEntry, ParquetChunk, ParquetChunkMapping, ParquetChunkMappingAxis, ParquetChunkMappingColumn, ParquetChunkMetadata, ParquetChunkStats, ParquetPartitionedDataInfo, ParquetPartitionedDataInfoEntries, PartitionedDataInfoEntries, dataInfoToEntries, entriesToDataInfo, isDataInfo, isDataInfoEntries, isPartitionedDataInfoEntries, mapDataInfo, mapDataInfoEntries, visitDataInfo } from "./drivers/pframe/data_info.js";
-import { AAxisSelector, ADomain, AnchorAxisIdOrRefBasic, AnchorAxisRef, AnchorAxisRefByIdx, AnchorAxisRefByMatcher, AnchorAxisRefByName, AnchorDomainRef, AnchoredColumnMatchStrategy, AnchoredPColumnId, AnchoredPColumnSelector, AxisSelector, PColumnSelector, SingleAxisSelector, isAnchoredPColumnId, matchAxis, matchPColumn, selectorsToPredicate } from "./drivers/pframe/spec/selectors.js";
+import { AAxisSelector, ADomain, AnchorAxisIdOrRefBasic, AnchorAxisRef, AnchorAxisRefByIdx, AnchorAxisRefByMatcher, AnchorAxisRefByName, AnchorDomainRef, AnchoredColumnMatchStrategy, AnchoredPColumnId, AnchoredPColumnSelector, LegacyAxisSelector, PColumnSelector, SingleAxisSelector, isAnchoredPColumnId, legacyColumnSelectorsToPredicate, matchAxis, matchPColumn } from "./drivers/pframe/spec/selectors.js";
 import { AxisFilter, AxisFilterByIdx, AxisFilterByName, AxisFilterValue, FilteredPColumn, FilteredPColumnId, isFilteredPColumn } from "./drivers/pframe/spec/filtered_column.js";
 import { SUniversalPColumnId, UniversalPColumnId, parseColumnId, stringifyColumnId } from "./drivers/pframe/spec/ids.js";
 import { FilterSpec, FilterSpecLeaf, FilterSpecNode, FilterSpecOfType, FilterSpecType, InferFilterSpecCommonLeaf, InferFilterSpecCommonNode, InferFilterSpecLeaf, InferFilterSpecLeafColumn, RootFilterSpec } from "./drivers/pframe/filter_spec.js";
@@ -45,6 +45,7 @@ import { collectSpecQueryColumns, isBooleanExpression, mapSpecQueryColumns, sort
 import { PFrameDriver, PFrameHandle, PTableHandle } from "./drivers/pframe/driver.js";
 import { CompositeLinkerMap, LinkerMap } from "./drivers/pframe/linker_columns.js";
 import { FileRange, ImportFileHandle, ImportFileHandleIndex, ImportFileHandleUpload, ListFilesResult, LocalImportFileHandle, LsDriver, LsEntry, OpenDialogFilter, OpenDialogOps, OpenMultipleFilesResponse, OpenSingleFileResponse, StorageEntry, StorageHandle, StorageHandleLocal, StorageHandleRemote, getFileNameFromHandle, getFilePathFromHandle, isImportFileHandleIndex, isImportFileHandleUpload } from "./drivers/ls.js";
+import { AxisQualification, ColumnAxesWithQualifications, DiscoverColumnsConstraints, DiscoverColumnsLinkerStep, DiscoverColumnsMappingVariant, DiscoverColumnsRequest, DiscoverColumnsResponse, DiscoverColumnsResponseHit, DiscoverColumnsResponseQualifications, DiscoverColumnsStepInfo, MatcherMap, MultiAxisSelector, MultiColumnSelector, PSpecDriver, SpecFrameHandle, StringMatcher } from "./drivers/pspec.js";
 import { ChunkedStreamReader, ChunkedStreamReaderOptions, ErrorHandlerStatus } from "./drivers/ChunkedStreamReader.js";
 import "./drivers/index.js";
 import { DriverKit } from "./driver_kit.js";
@@ -55,4 +56,5 @@ import { ValueOrError, mapValueInVOE } from "./value_or_error.js";
 import { Base64Compatible, Base64Encoded, base64Decode, base64Encode } from "./base64.js";
 import { assertNever, uniqueBy } from "./util.js";
 import { BasicHttpAuth, HttpAuth, parseHttpAuth, serializeHttpAuth } from "./httpAuth.js";
-export { AAxisSelector, ADomain, AbortError, AllRequiresFeatureFlags, AllSupportsFeatureFlags, AnchorAxisIdOrRefBasic, AnchorAxisRef, AnchorAxisRefByIdx, AnchorAxisRefByMatcher, AnchorAxisRefByName, AnchorDomainRef, AnchoredColumnMatchStrategy, AnchoredIdDeriver, AnchoredPColumnId, AnchoredPColumnSelector, Annotation, AnnotationJson, AnyFunction, AnyLogHandle, ArchiveFormat, ArrayTypeUnion, ArtificialColumnJoinEntry, Assert, AssertKeysEqual, AuthorMarker, AxesId, AxesSpec, AxisFilter, AxisFilterByIdx, AxisFilterByName, AxisFilterValue, AxisId, AxisSelector, AxisSpec, AxisSpecNormalized, AxisTree, AxisValueType, Base64Compatible, Base64Encoded, BasicHttpAuth, BinaryChunk, BinaryPartitionedDataInfo, BinaryPartitionedDataInfoEntries, BlobDriver, BlobHandleAndSize, BlobLike, BlobToURLDriver, BlockCodeFeatureFlags, BlockCodeKnownFeatureFlags, BlockCodeWithInfo, BlockConfigContainer, BlockConfigGeneric, BlockConfigV3Generic, BlockConfigV4Generic, BlockOutputsBase, BlockRenderingMode, BlockSection, BlockSectionDelimiter, BlockSectionLink, BlockSectionLinkAppearance, BlockState, BlockStateV3, BlockUIURL, Branded, CalculateTableDataRequest, CalculateTableDataResponse, CanonicalizedJson, ChunkedStreamReader, ChunkedStreamReaderOptions, Code, ColumnFilter, ColumnJoinEntry, ColumnValueType, CompositeLinkerMap, ConstantAxisFilter, ContentHandler, DataExprAxisRef, DataExprColumnRef, DataInfo, DataInfoEntries, DataQuery, DataQueryBooleanExpression, DataQueryColumn, DataQueryExpression, DataQueryFilter, DataQueryInlineColumn, DataQueryJoinEntry, DataQueryOuterJoin, DataQuerySliceAxes, DataQuerySort, DataQuerySparseToDenseColumn, DataQuerySymmetricJoin, DefaultNavigationState, Domain, DomainJson, DriverKit, ErrorHandlerStatus, FileLike, FileRange, FilterKeysByPrefix, FilterSpec, FilterSpecLeaf, FilterSpecNode, FilterSpecOfType, FilterSpecType, FilteredPColumn, FilteredPColumnId, FindColumnsRequest, FindColumnsResponse, FolderURL, FrontendDriver, FullJoin, FullPTableColumnData, GetContentOptions, HttpAuth, ImportFileHandle, ImportFileHandleIndex, ImportFileHandleUpload, ImportProgress, ImportStatus, IncompatibleFlagsError, InferFilterSpecCommonLeaf, InferFilterSpecCommonNode, InferFilterSpecLeaf, InferFilterSpecLeafColumn, InlineColumnJoinEntry, InnerJoin, Is, IsSubtypeOf, JoinEntry, JsonCompatible, JsonDataInfo, JsonDataInfoEntries, JsonPartitionedDataInfo, JsonPartitionedDataInfoEntries, JsonSerializable, LinkerMap, ListFilesResult, ListOptionBase, LiveLogHandle, LocalBlobHandle, LocalBlobHandleAndSize, LocalImportFileHandle, LogsDriver, LsDriver, LsEntry, Metadata, MetadataJson, NativePObjectId, NavigationState, OpenDialogFilter, OpenDialogOps, OpenMultipleFilesResponse, OpenSingleFileResponse, Option, OuterJoin, OutputWithStatus, PAxisName, PColumn, PColumnDataEntry, PColumnIdAndSpec, PColumnInfo, PColumnKey, PColumnLazy, PColumnName, PColumnSelector, PColumnSpec, PColumnSpecId, PColumnValue, PColumnValues, PColumnValuesEntry, PDataColumnSpec, PFrame, PFrameDef, PFrameDriver, PFrameDriverError, PFrameError, PFrameHandle, PObject, PObjectId, PObjectSpec, PSpecPredicate, PTable, PTableAbsent, PTableColumnId, PTableColumnIdAxis, PTableColumnIdColumn, PTableColumnSpec, PTableColumnSpecAxis, PTableColumnSpecColumn, PTableDef, PTableDefV2, PTableHandle, PTableNA, PTableRecordFilter, PTableRecordSingleValueFilterV2, PTableShape, PTableSorting, PTableValue, PTableValueAxis, PTableValueBranded, PTableValueData, PTableValueDataBranded, PTableValueDouble, PTableValueFloat, PTableValueInt, PTableValueLong, PTableValueString, PTableVector, PTableVectorTyped, PUniversalColumnSpec, PVectorData, PVectorDataBytes, PVectorDataDouble, PVectorDataFloat, PVectorDataInt, PVectorDataLong, PVectorDataString, PVectorDataTyped, ParquetChunk, ParquetChunkMapping, ParquetChunkMappingAxis, ParquetChunkMappingColumn, ParquetChunkMetadata, ParquetChunkStats, ParquetPartitionedDataInfo, ParquetPartitionedDataInfoEntries, PartitionedDataInfoEntries, PlId, PlIdBytes, PlIdLength, PlRef, ProgressLogWithInfo, RangeBytes, ReadyLogHandle, Ref, RemoteBlobHandle, RemoteBlobHandleAndSize, ResolveAnchorsOptions, ResultCollection, ResultOrError, ResultPoolEntry, RootFilterSpec, RuntimeCapabilities, SUniversalPColumnId, SerializedError, SingleAxisSelector, SingleValueAndPredicateV2, SingleValueEqualPredicate, SingleValueGreaterOrEqualPredicate, SingleValueGreaterPredicate, SingleValueIEqualPredicate, SingleValueInSetPredicate, SingleValueIsNAPredicate, SingleValueLessOrEqualPredicate, SingleValueLessPredicate, SingleValueMatchesPredicate, SingleValueNotPredicateV2, SingleValueOrPredicateV2, SingleValuePredicateV2, SingleValueStringContainsFuzzyPredicate, SingleValueStringContainsPredicate, SingleValueStringIContainsFuzzyPredicate, SingleValueStringIContainsPredicate, SlicedColumnJoinEntry, SpecExprAxisRef, SpecExprColumnRef, SpecQuery, SpecQueryBooleanExpression, SpecQueryColumn, SpecQueryExpression, SpecQueryFilter, SpecQueryInlineColumn, SpecQueryJoinEntry, SpecQueryOuterJoin, SpecQuerySliceAxes, SpecQuerySort, SpecQuerySparseToDenseColumn, SpecQuerySymmetricJoin, StorageEntry, StorageHandle, StorageHandleLocal, StorageHandleRemote, StreamingApiResponse, StreamingApiResponseHandleOutdated, StreamingApiResponseOk, StringifiedJson, SupportedRequirement, TableRange, UiError, UniqueValuesRequest, UniqueValuesResponse, UniversalPColumnId, ValueOrError, ValueType, ValueTypeSupported, ValueWithUTag, ValueWithUTagAndAuthor, assertNever, base64Decode, base64Encode, bigintReplacer, canonicalizeAxisId, canonicalizeAxisWithParents, canonicalizeJson, checkBlockFlag, collectSpecQueryColumns, createPlRef, dataInfoToEntries, deriveNativeId, deserializeError, deserializeResult, digestPlId, ensureError, ensurePColumn, entriesToDataInfo, executePSpecPredicate, extractAllColumns, extractAllRequirements, extractAllSupports, extractCodeWithInfo, extractConfigGeneric, getArrayFromAxisTree, getAxesId, getAxesTree, getAxisId, getColumnIdAndSpec, getDenormalizedAxesList, getFileNameFromHandle, getFilePathFromHandle, getNormalizedAxesList, getPColumnSpecId, getPTableColumnId, getSetFromAxisTree, getTypeFromPColumnOrAxisSpec, hasAbortError, isAbortError, isAggregateError, isAnchoredPColumnId, isAxisId, isBlockUIURL, isBooleanExpression, isDataInfo, isDataInfoEntries, isFilteredPColumn, isFolderURL, isImportFileHandleIndex, isImportFileHandleUpload, isLabelColumn, isLinkerColumn, isLiveLog, isPColumn, isPColumnResult, isPColumnSpec, isPColumnSpecResult, isPFrameDriverError, isPFrameError, isPTableAbsent, isPTableNA, isPTableValueAxis, isPartitionedDataInfoEntries, isPlRef, mapDataInfo, mapDataInfoEntries, mapJoinEntry, mapPObjectData, mapPTableDef, mapPTableDefV2, mapSpecQueryColumns, mapValueInVOE, matchAxis, matchAxisId, matchPColumn, newRangeBytesOpt, pTableValue, pTableValueBranded, parseColumnId, parseHttpAuth, parseJson, plId, plRefsEqual, readAnnotation, readAnnotationJson, readAnnotationJsonOrThrow, readDomain, readDomainJson, readDomainJsonOrThrow, readMetadata, readMetadataJson, readMetadataJsonOrThrow, resolveAnchors, selectorsToPredicate, serializeError, serializeHttpAuth, serializeResult, sortJoinEntry, sortPTableDef, sortSpecQuery, stringifyColumnId, stringifyJson, traverseQuerySpec, uniqueBy, uniquePlId, unwrapResult, validateRangeBytes, visitDataInfo, withEnrichments, wrapAndSerialize, wrapAndSerializeAsync, wrapAsyncCallback, wrapCallback };
+import { ResourceTypeName, ResourceTypePrefix } from "./resource_types.js";
+export { AAxisSelector, ADomain, AbortError, AllRequiresFeatureFlags, AllSupportsFeatureFlags, AnchorAxisIdOrRefBasic, AnchorAxisRef, AnchorAxisRefByIdx, AnchorAxisRefByMatcher, AnchorAxisRefByName, AnchorDomainRef, AnchoredColumnMatchStrategy, AnchoredIdDeriver, AnchoredPColumnId, AnchoredPColumnSelector, Annotation, AnnotationJson, AnyFunction, AnyLogHandle, ArchiveFormat, ArrayTypeUnion, ArtificialColumnJoinEntry, Assert, AssertKeysEqual, AuthorMarker, AxesId, AxesSpec, AxisFilter, AxisFilterByIdx, AxisFilterByName, AxisFilterValue, AxisId, AxisQualification, AxisSpec, AxisSpecNormalized, AxisTree, AxisValueType, Base64Compatible, Base64Encoded, BasicHttpAuth, BinaryChunk, BinaryPartitionedDataInfo, BinaryPartitionedDataInfoEntries, BlobDriver, BlobHandleAndSize, BlobLike, BlobToURLDriver, BlockCodeFeatureFlags, BlockCodeKnownFeatureFlags, BlockCodeWithInfo, BlockConfigContainer, BlockConfigGeneric, BlockConfigV3Generic, BlockConfigV4Generic, BlockOutputsBase, BlockRenderingMode, BlockSection, BlockSectionDelimiter, BlockSectionLink, BlockSectionLinkAppearance, BlockState, BlockStateV3, BlockUIURL, Branded, CalculateTableDataRequest, CalculateTableDataResponse, CanonicalizedJson, ChunkedStreamReader, ChunkedStreamReaderOptions, Code, ColumnAxesWithQualifications, ColumnFilter, ColumnJoinEntry, ColumnValueType, CompositeLinkerMap, ConstantAxisFilter, ContentHandler, DataExprAxisRef, DataExprColumnRef, DataInfo, DataInfoEntries, DataQuery, DataQueryBooleanExpression, DataQueryColumn, DataQueryExpression, DataQueryFilter, DataQueryInlineColumn, DataQueryJoinEntry, DataQueryOuterJoin, DataQuerySliceAxes, DataQuerySort, DataQuerySparseToDenseColumn, DataQuerySymmetricJoin, DefaultNavigationState, DiscoverColumnsConstraints, DiscoverColumnsLinkerStep, DiscoverColumnsMappingVariant, DiscoverColumnsRequest, DiscoverColumnsResponse, DiscoverColumnsResponseHit, DiscoverColumnsResponseQualifications, DiscoverColumnsStepInfo, Domain, DomainJson, DriverKit, ErrorHandlerStatus, FileLike, FileRange, FilterKeysByPrefix, FilterSpec, FilterSpecLeaf, FilterSpecNode, FilterSpecOfType, FilterSpecType, FilteredPColumn, FilteredPColumnId, FindColumnsRequest, FindColumnsResponse, FolderURL, FrontendDriver, FullJoin, FullPTableColumnData, GetContentOptions, HttpAuth, ImportFileHandle, ImportFileHandleIndex, ImportFileHandleUpload, ImportProgress, ImportStatus, IncompatibleFlagsError, InferFilterSpecCommonLeaf, InferFilterSpecCommonNode, InferFilterSpecLeaf, InferFilterSpecLeafColumn, InlineColumnJoinEntry, InnerJoin, Is, IsSubtypeOf, JoinEntry, JsonCompatible, JsonDataInfo, JsonDataInfoEntries, JsonPartitionedDataInfo, JsonPartitionedDataInfoEntries, JsonSerializable, LegacyAxisSelector, LinkerMap, ListFilesResult, ListOptionBase, LiveLogHandle, LocalBlobHandle, LocalBlobHandleAndSize, LocalImportFileHandle, LogsDriver, LsDriver, LsEntry, MatcherMap, Metadata, MetadataJson, MultiAxisSelector, MultiColumnSelector, NativePObjectId, NavigationState, OpenDialogFilter, OpenDialogOps, OpenMultipleFilesResponse, OpenSingleFileResponse, Option, OuterJoin, OutputWithStatus, PAxisName, PColumn, PColumnDataEntry, PColumnIdAndSpec, PColumnInfo, PColumnKey, PColumnLazy, PColumnName, PColumnSelector, PColumnSpec, PColumnSpecId, PColumnValue, PColumnValues, PColumnValuesEntry, PDataColumnSpec, PFrame, PFrameDef, PFrameDriver, PFrameDriverError, PFrameError, PFrameHandle, PObject, PObjectId, PObjectSpec, PSpecDriver, PSpecPredicate, PTable, PTableAbsent, PTableColumnId, PTableColumnIdAxis, PTableColumnIdColumn, PTableColumnSpec, PTableColumnSpecAxis, PTableColumnSpecColumn, PTableDef, PTableDefV2, PTableHandle, PTableNA, PTableRecordFilter, PTableRecordSingleValueFilterV2, PTableShape, PTableSorting, PTableValue, PTableValueAxis, PTableValueBranded, PTableValueData, PTableValueDataBranded, PTableValueDouble, PTableValueFloat, PTableValueInt, PTableValueLong, PTableValueString, PTableVector, PTableVectorTyped, PUniversalColumnSpec, PVectorData, PVectorDataBytes, PVectorDataDouble, PVectorDataFloat, PVectorDataInt, PVectorDataLong, PVectorDataString, PVectorDataTyped, ParquetChunk, ParquetChunkMapping, ParquetChunkMappingAxis, ParquetChunkMappingColumn, ParquetChunkMetadata, ParquetChunkStats, ParquetPartitionedDataInfo, ParquetPartitionedDataInfoEntries, PartitionedDataInfoEntries, PlId, PlIdBytes, PlIdLength, PlRef, ProgressLogWithInfo, RangeBytes, ReadyLogHandle, Ref, RemoteBlobHandle, RemoteBlobHandleAndSize, ResolveAnchorsOptions, ResourceTypeName, ResourceTypePrefix, ResultCollection, ResultOrError, ResultPoolEntry, RootFilterSpec, RuntimeCapabilities, SUniversalPColumnId, SerializedError, SingleAxisSelector, SingleValueAndPredicateV2, SingleValueEqualPredicate, SingleValueGreaterOrEqualPredicate, SingleValueGreaterPredicate, SingleValueIEqualPredicate, SingleValueInSetPredicate, SingleValueIsNAPredicate, SingleValueLessOrEqualPredicate, SingleValueLessPredicate, SingleValueMatchesPredicate, SingleValueNotPredicateV2, SingleValueOrPredicateV2, SingleValuePredicateV2, SingleValueStringContainsFuzzyPredicate, SingleValueStringContainsPredicate, SingleValueStringIContainsFuzzyPredicate, SingleValueStringIContainsPredicate, SlicedColumnJoinEntry, SpecExprAxisRef, SpecExprColumnRef, SpecFrameHandle, SpecQuery, SpecQueryBooleanExpression, SpecQueryColumn, SpecQueryExpression, SpecQueryFilter, SpecQueryInlineColumn, SpecQueryJoinEntry, SpecQueryOuterJoin, SpecQuerySliceAxes, SpecQuerySort, SpecQuerySparseToDenseColumn, SpecQuerySymmetricJoin, StorageEntry, StorageHandle, StorageHandleLocal, StorageHandleRemote, StreamingApiResponse, StreamingApiResponseHandleOutdated, StreamingApiResponseOk, StringMatcher, StringifiedJson, SupportedRequirement, TableRange, UiError, UniqueValuesRequest, UniqueValuesResponse, UniversalPColumnId, ValueOrError, ValueType, ValueTypeSupported, ValueWithUTag, ValueWithUTagAndAuthor, assertNever, base64Decode, base64Encode, bigintReplacer, canonicalizeAxisId, canonicalizeAxisWithParents, canonicalizeJson, checkBlockFlag, collectSpecQueryColumns, createPlRef, dataInfoToEntries, deriveNativeId, deserializeError, deserializeResult, digestPlId, ensureError, ensurePColumn, entriesToDataInfo, executePSpecPredicate, extractAllColumns, extractAllRequirements, extractAllSupports, extractCodeWithInfo, extractConfigGeneric, getArrayFromAxisTree, getAxesId, getAxesTree, getAxisId, getColumnIdAndSpec, getDenormalizedAxesList, getFileNameFromHandle, getFilePathFromHandle, getNormalizedAxesList, getPColumnSpecId, getPTableColumnId, getSetFromAxisTree, getTypeFromPColumnOrAxisSpec, hasAbortError, isAbortError, isAggregateError, isAnchoredPColumnId, isAxisId, isBlockUIURL, isBooleanExpression, isDataInfo, isDataInfoEntries, isFilteredPColumn, isFolderURL, isImportFileHandleIndex, isImportFileHandleUpload, isLabelColumn, isLinkerColumn, isLiveLog, isPColumn, isPColumnResult, isPColumnSpec, isPColumnSpecResult, isPFrameDriverError, isPFrameError, isPTableAbsent, isPTableNA, isPTableValueAxis, isPartitionedDataInfoEntries, isPlRef, legacyColumnSelectorsToPredicate, mapDataInfo, mapDataInfoEntries, mapJoinEntry, mapPObjectData, mapPTableDef, mapPTableDefV2, mapSpecQueryColumns, mapValueInVOE, matchAxis, matchAxisId, matchPColumn, newRangeBytesOpt, pTableValue, pTableValueBranded, parseColumnId, parseHttpAuth, parseJson, plId, plRefsEqual, readAnnotation, readAnnotationJson, readAnnotationJsonOrThrow, readDomain, readDomainJson, readDomainJsonOrThrow, readMetadata, readMetadataJson, readMetadataJsonOrThrow, resolveAnchors, serializeError, serializeHttpAuth, serializeResult, sortJoinEntry, sortPTableDef, sortSpecQuery, stringifyColumnId, stringifyJson, traverseQuerySpec, uniqueBy, uniquePlId, unwrapResult, validateRangeBytes, visitDataInfo, withEnrichments, wrapAndSerialize, wrapAndSerializeAsync, wrapAsyncCallback, wrapCallback };

package/dist/index.js

@@ -20,7 +20,7 @@ import { AnchoredIdDeriver, resolveAnchors } from "./drivers/pframe/spec/anchore
 import { isFilteredPColumn } from "./drivers/pframe/spec/filtered_column.js";
 import { ensurePColumn, extractAllColumns, isPColumn, isPColumnResult, isPColumnSpec, isPColumnSpecResult, mapPObjectData } from "./pool/spec.js";
 import { executePSpecPredicate } from "./pool/query.js";
-import { isAnchoredPColumnId, matchAxis, matchPColumn, selectorsToPredicate } from "./drivers/pframe/spec/selectors.js";
+import { isAnchoredPColumnId, legacyColumnSelectorsToPredicate, matchAxis, matchPColumn } from "./drivers/pframe/spec/selectors.js";
 import { deriveNativeId } from "./drivers/pframe/spec/native_id.js";
 import { LinkerMap } from "./drivers/pframe/linker_columns.js";
 import { ChunkedStreamReader } from "./drivers/ChunkedStreamReader.js";
@@ -33,5 +33,6 @@ import { PlRef, createPlRef, isPlRef, plRefsEqual, withEnrichments } from "./ref
 import { mapValueInVOE } from "./value_or_error.js";
 import { base64Decode, base64Encode } from "./base64.js";
 import { parseHttpAuth, serializeHttpAuth } from "./httpAuth.js";
+import { ResourceTypeName, ResourceTypePrefix } from "./resource_types.js";
 
-export { AbortError, AllRequiresFeatureFlags, AllSupportsFeatureFlags, AnchoredIdDeriver, Annotation, AnnotationJson, ChunkedStreamReader, Code, DefaultNavigationState, Domain, DomainJson, IncompatibleFlagsError, LinkerMap, PAxisName, PColumnName, PFrameDriverError, PFrameError, PTableAbsent, PTableNA, PlId, PlIdBytes, PlIdLength, PlRef, RangeBytes, RuntimeCapabilities, UiError, ValueType, assertNever, base64Decode, base64Encode, bigintReplacer, canonicalizeAxisId, canonicalizeAxisWithParents, canonicalizeJson, checkBlockFlag, collectSpecQueryColumns, createPlRef, dataInfoToEntries, deriveNativeId, deserializeError, deserializeResult, digestPlId, ensureError, ensurePColumn, entriesToDataInfo, executePSpecPredicate, extractAllColumns, extractAllRequirements, extractAllSupports, extractCodeWithInfo, extractConfigGeneric, getArrayFromAxisTree, getAxesId, getAxesTree, getAxisId, getColumnIdAndSpec, getDenormalizedAxesList, getFileNameFromHandle, getFilePathFromHandle, getNormalizedAxesList, getPColumnSpecId, getPTableColumnId, getSetFromAxisTree, getTypeFromPColumnOrAxisSpec, hasAbortError, isAbortError, isAggregateError, isAnchoredPColumnId, isAxisId, isBlockUIURL, isBooleanExpression, isDataInfo, isDataInfoEntries, isFilteredPColumn, isFolderURL, isImportFileHandleIndex, isImportFileHandleUpload, isLabelColumn, isLinkerColumn, isLiveLog, isPColumn, isPColumnResult, isPColumnSpec, isPColumnSpecResult, isPFrameDriverError, isPFrameError, isPTableAbsent, isPTableNA, isPTableValueAxis, isPartitionedDataInfoEntries, isPlRef, mapDataInfo, mapDataInfoEntries, mapJoinEntry, mapPObjectData, mapPTableDef, mapPTableDefV2, mapSpecQueryColumns, mapValueInVOE, matchAxis, matchAxisId, matchPColumn, newRangeBytesOpt, pTableValue, pTableValueBranded, parseColumnId, parseHttpAuth, parseJson, plId, plRefsEqual, readAnnotation, readAnnotationJson, readAnnotationJsonOrThrow, readDomain, readDomainJson, readDomainJsonOrThrow, readMetadata, readMetadataJson, readMetadataJsonOrThrow, resolveAnchors, selectorsToPredicate, serializeError, serializeHttpAuth, serializeResult, sortJoinEntry, sortPTableDef, sortSpecQuery, stringifyColumnId, stringifyJson, traverseQuerySpec, uniqueBy, uniquePlId, unwrapResult, validateRangeBytes, visitDataInfo, withEnrichments, wrapAndSerialize, wrapAndSerializeAsync, wrapAsyncCallback, wrapCallback };
+export { AbortError, AllRequiresFeatureFlags, AllSupportsFeatureFlags, AnchoredIdDeriver, Annotation, AnnotationJson, ChunkedStreamReader, Code, DefaultNavigationState, Domain, DomainJson, IncompatibleFlagsError, LinkerMap, PAxisName, PColumnName, PFrameDriverError, PFrameError, PTableAbsent, PTableNA, PlId, PlIdBytes, PlIdLength, PlRef, RangeBytes, ResourceTypeName, ResourceTypePrefix, RuntimeCapabilities, UiError, ValueType, assertNever, base64Decode, base64Encode, bigintReplacer, canonicalizeAxisId, canonicalizeAxisWithParents, canonicalizeJson, checkBlockFlag, collectSpecQueryColumns, createPlRef, dataInfoToEntries, deriveNativeId, deserializeError, deserializeResult, digestPlId, ensureError, ensurePColumn, entriesToDataInfo, executePSpecPredicate, extractAllColumns, extractAllRequirements, extractAllSupports, extractCodeWithInfo, extractConfigGeneric, getArrayFromAxisTree, getAxesId, getAxesTree, getAxisId, getColumnIdAndSpec, getDenormalizedAxesList, getFileNameFromHandle, getFilePathFromHandle, getNormalizedAxesList, getPColumnSpecId, getPTableColumnId, getSetFromAxisTree, getTypeFromPColumnOrAxisSpec, hasAbortError, isAbortError, isAggregateError, isAnchoredPColumnId, isAxisId, isBlockUIURL, isBooleanExpression, isDataInfo, isDataInfoEntries, isFilteredPColumn, isFolderURL, isImportFileHandleIndex, isImportFileHandleUpload, isLabelColumn, isLinkerColumn, isLiveLog, isPColumn, isPColumnResult, isPColumnSpec, isPColumnSpecResult, isPFrameDriverError, isPFrameError, isPTableAbsent, isPTableNA, isPTableValueAxis, isPartitionedDataInfoEntries, isPlRef, legacyColumnSelectorsToPredicate, mapDataInfo, mapDataInfoEntries, mapJoinEntry, mapPObjectData, mapPTableDef, mapPTableDefV2, mapSpecQueryColumns, mapValueInVOE, matchAxis, matchAxisId, matchPColumn, newRangeBytesOpt, pTableValue, pTableValueBranded, parseColumnId, parseHttpAuth, parseJson, plId, plRefsEqual, readAnnotation, readAnnotationJson, readAnnotationJsonOrThrow, readDomain, readDomainJson, readDomainJsonOrThrow, readMetadata, readMetadataJson, readMetadataJsonOrThrow, resolveAnchors, serializeError, serializeHttpAuth, serializeResult, sortJoinEntry, sortPTableDef, sortSpecQuery, stringifyColumnId, stringifyJson, traverseQuerySpec, uniqueBy, uniquePlId, unwrapResult, validateRangeBytes, visitDataInfo, withEnrichments, wrapAndSerialize, wrapAndSerializeAsync, wrapAsyncCallback, wrapCallback };

package/dist/resource_types.cjs

@@ -0,0 +1,53 @@
+
+//#region src/resource_types.ts
+/** Well-known resource type names used across the platform. */
+const ResourceTypeName = {
+	StreamManager: "StreamManager",
+	StdMap: "StdMap",
+	StdMapSlash: "std/map",
+	EphStdMap: "EphStdMap",
+	PFrame: "PFrame",
+	ParquetChunk: "ParquetChunk",
+	BContext: "BContext",
+	BlockPackCustom: "BlockPackCustom",
+	BinaryMap: "BinaryMap",
+	BinaryValue: "BinaryValue",
+	BlobMap: "BlobMap",
+	BResolveSingle: "BResolveSingle",
+	BResolveSingleNoResult: "BResolveSingleNoResult",
+	BQueryResult: "BQueryResult",
+	TengoTemplate: "TengoTemplate",
+	TengoLib: "TengoLib",
+	SoftwareInfo: "SoftwareInfo",
+	Dummy: "Dummy",
+	JsonResourceError: "json/resourceError",
+	JsonObject: "json/object",
+	JsonGzObject: "json-gz/object",
+	JsonString: "json/string",
+	JsonArray: "json/array",
+	JsonNumber: "json/number",
+	BContextEnd: "BContextEnd",
+	FrontendFromUrl: "Frontend/FromUrl",
+	FrontendFromFolder: "Frontend/FromFolder",
+	BObjectSpec: "BObjectSpec",
+	Blob: "Blob",
+	Null: "Null",
+	Binary: "binary",
+	LSProvider: "LSProvider",
+	UserProject: "UserProject",
+	Projects: "Projects",
+	ClientRoot: "ClientRoot"
+};
+/** Resource type name prefix constants. */
+const ResourceTypePrefix = {
+	Blob: "Blob/",
+	BlobUpload: "BlobUpload/",
+	BlobIndex: "BlobIndex/",
+	PColumnData: "PColumnData/",
+	StreamWorkdir: "StreamWorkdir/"
+};
+
+//#endregion
+exports.ResourceTypeName = ResourceTypeName;
+exports.ResourceTypePrefix = ResourceTypePrefix;
+//# sourceMappingURL=resource_types.cjs.map

package/dist/resource_types.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"resource_types.cjs","names":[],"sources":["../src/resource_types.ts"],"sourcesContent":["/** Well-known resource type names used across the platform. */\nexport const ResourceTypeName = {\n  StreamManager: \"StreamManager\",\n  StdMap: \"StdMap\",\n  StdMapSlash: \"std/map\",\n  EphStdMap: \"EphStdMap\",\n  PFrame: \"PFrame\",\n  ParquetChunk: \"ParquetChunk\",\n  BContext: \"BContext\",\n  BlockPackCustom: \"BlockPackCustom\",\n  BinaryMap: \"BinaryMap\",\n  BinaryValue: \"BinaryValue\",\n  BlobMap: \"BlobMap\",\n  BResolveSingle: \"BResolveSingle\",\n  BResolveSingleNoResult: \"BResolveSingleNoResult\",\n  BQueryResult: \"BQueryResult\",\n  TengoTemplate: \"TengoTemplate\",\n  TengoLib: \"TengoLib\",\n  SoftwareInfo: \"SoftwareInfo\",\n  Dummy: \"Dummy\",\n  JsonResourceError: \"json/resourceError\",\n  JsonObject: \"json/object\",\n  JsonGzObject: \"json-gz/object\",\n  JsonString: \"json/string\",\n  JsonArray: \"json/array\",\n  JsonNumber: \"json/number\",\n  BContextEnd: \"BContextEnd\",\n  FrontendFromUrl: \"Frontend/FromUrl\",\n  FrontendFromFolder: \"Frontend/FromFolder\",\n  BObjectSpec: \"BObjectSpec\",\n  Blob: \"Blob\",\n  Null: \"Null\",\n  Binary: \"binary\",\n  LSProvider: \"LSProvider\",\n  UserProject: \"UserProject\",\n  Projects: \"Projects\",\n  ClientRoot: \"ClientRoot\",\n} as const;\n\n/** Resource type name prefix constants. */\nexport const ResourceTypePrefix = {\n  Blob: \"Blob/\",\n  BlobUpload: \"BlobUpload/\",\n  BlobIndex: \"BlobIndex/\",\n  PColumnData: \"PColumnData/\",\n  StreamWorkdir: \"StreamWorkdir/\",\n} as const;\n"],"mappings":";;;AACA,MAAa,mBAAmB;CAC9B,eAAe;CACf,QAAQ;CACR,aAAa;CACb,WAAW;CACX,QAAQ;CACR,cAAc;CACd,UAAU;CACV,iBAAiB;CACjB,WAAW;CACX,aAAa;CACb,SAAS;CACT,gBAAgB;CAChB,wBAAwB;CACxB,cAAc;CACd,eAAe;CACf,UAAU;CACV,cAAc;CACd,OAAO;CACP,mBAAmB;CACnB,YAAY;CACZ,cAAc;CACd,YAAY;CACZ,WAAW;CACX,YAAY;CACZ,aAAa;CACb,iBAAiB;CACjB,oBAAoB;CACpB,aAAa;CACb,MAAM;CACN,MAAM;CACN,QAAQ;CACR,YAAY;CACZ,aAAa;CACb,UAAU;CACV,YAAY;CACb;;AAGD,MAAa,qBAAqB;CAChC,MAAM;CACN,YAAY;CACZ,WAAW;CACX,aAAa;CACb,eAAe;CAChB"}

package/dist/resource_types.d.ts

@@ -0,0 +1,50 @@
+//#region src/resource_types.d.ts
+/** Well-known resource type names used across the platform. */
+declare const ResourceTypeName: {
+  readonly StreamManager: "StreamManager";
+  readonly StdMap: "StdMap";
+  readonly StdMapSlash: "std/map";
+  readonly EphStdMap: "EphStdMap";
+  readonly PFrame: "PFrame";
+  readonly ParquetChunk: "ParquetChunk";
+  readonly BContext: "BContext";
+  readonly BlockPackCustom: "BlockPackCustom";
+  readonly BinaryMap: "BinaryMap";
+  readonly BinaryValue: "BinaryValue";
+  readonly BlobMap: "BlobMap";
+  readonly BResolveSingle: "BResolveSingle";
+  readonly BResolveSingleNoResult: "BResolveSingleNoResult";
+  readonly BQueryResult: "BQueryResult";
+  readonly TengoTemplate: "TengoTemplate";
+  readonly TengoLib: "TengoLib";
+  readonly SoftwareInfo: "SoftwareInfo";
+  readonly Dummy: "Dummy";
+  readonly JsonResourceError: "json/resourceError";
+  readonly JsonObject: "json/object";
+  readonly JsonGzObject: "json-gz/object";
+  readonly JsonString: "json/string";
+  readonly JsonArray: "json/array";
+  readonly JsonNumber: "json/number";
+  readonly BContextEnd: "BContextEnd";
+  readonly FrontendFromUrl: "Frontend/FromUrl";
+  readonly FrontendFromFolder: "Frontend/FromFolder";
+  readonly BObjectSpec: "BObjectSpec";
+  readonly Blob: "Blob";
+  readonly Null: "Null";
+  readonly Binary: "binary";
+  readonly LSProvider: "LSProvider";
+  readonly UserProject: "UserProject";
+  readonly Projects: "Projects";
+  readonly ClientRoot: "ClientRoot";
+};
+/** Resource type name prefix constants. */
+declare const ResourceTypePrefix: {
+  readonly Blob: "Blob/";
+  readonly BlobUpload: "BlobUpload/";
+  readonly BlobIndex: "BlobIndex/";
+  readonly PColumnData: "PColumnData/";
+  readonly StreamWorkdir: "StreamWorkdir/";
+};
+//#endregion
+export { ResourceTypeName, ResourceTypePrefix };
+//# sourceMappingURL=resource_types.d.ts.map

package/dist/resource_types.js

@@ -0,0 +1,51 @@
+//#region src/resource_types.ts
+/** Well-known resource type names used across the platform. */
+const ResourceTypeName = {
+	StreamManager: "StreamManager",
+	StdMap: "StdMap",
+	StdMapSlash: "std/map",
+	EphStdMap: "EphStdMap",
+	PFrame: "PFrame",
+	ParquetChunk: "ParquetChunk",
+	BContext: "BContext",
+	BlockPackCustom: "BlockPackCustom",
+	BinaryMap: "BinaryMap",
+	BinaryValue: "BinaryValue",
+	BlobMap: "BlobMap",
+	BResolveSingle: "BResolveSingle",
+	BResolveSingleNoResult: "BResolveSingleNoResult",
+	BQueryResult: "BQueryResult",
+	TengoTemplate: "TengoTemplate",
+	TengoLib: "TengoLib",
+	SoftwareInfo: "SoftwareInfo",
+	Dummy: "Dummy",
+	JsonResourceError: "json/resourceError",
+	JsonObject: "json/object",
+	JsonGzObject: "json-gz/object",
+	JsonString: "json/string",
+	JsonArray: "json/array",
+	JsonNumber: "json/number",
+	BContextEnd: "BContextEnd",
+	FrontendFromUrl: "Frontend/FromUrl",
+	FrontendFromFolder: "Frontend/FromFolder",
+	BObjectSpec: "BObjectSpec",
+	Blob: "Blob",
+	Null: "Null",
+	Binary: "binary",
+	LSProvider: "LSProvider",
+	UserProject: "UserProject",
+	Projects: "Projects",
+	ClientRoot: "ClientRoot"
+};
+/** Resource type name prefix constants. */
+const ResourceTypePrefix = {
+	Blob: "Blob/",
+	BlobUpload: "BlobUpload/",
+	BlobIndex: "BlobIndex/",
+	PColumnData: "PColumnData/",
+	StreamWorkdir: "StreamWorkdir/"
+};
+
+//#endregion
+export { ResourceTypeName, ResourceTypePrefix };
+//# sourceMappingURL=resource_types.js.map

package/dist/resource_types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resource_types.js","names":[],"sources":["../src/resource_types.ts"],"sourcesContent":["/** Well-known resource type names used across the platform. */\nexport const ResourceTypeName = {\n  StreamManager: \"StreamManager\",\n  StdMap: \"StdMap\",\n  StdMapSlash: \"std/map\",\n  EphStdMap: \"EphStdMap\",\n  PFrame: \"PFrame\",\n  ParquetChunk: \"ParquetChunk\",\n  BContext: \"BContext\",\n  BlockPackCustom: \"BlockPackCustom\",\n  BinaryMap: \"BinaryMap\",\n  BinaryValue: \"BinaryValue\",\n  BlobMap: \"BlobMap\",\n  BResolveSingle: \"BResolveSingle\",\n  BResolveSingleNoResult: \"BResolveSingleNoResult\",\n  BQueryResult: \"BQueryResult\",\n  TengoTemplate: \"TengoTemplate\",\n  TengoLib: \"TengoLib\",\n  SoftwareInfo: \"SoftwareInfo\",\n  Dummy: \"Dummy\",\n  JsonResourceError: \"json/resourceError\",\n  JsonObject: \"json/object\",\n  JsonGzObject: \"json-gz/object\",\n  JsonString: \"json/string\",\n  JsonArray: \"json/array\",\n  JsonNumber: \"json/number\",\n  BContextEnd: \"BContextEnd\",\n  FrontendFromUrl: \"Frontend/FromUrl\",\n  FrontendFromFolder: \"Frontend/FromFolder\",\n  BObjectSpec: \"BObjectSpec\",\n  Blob: \"Blob\",\n  Null: \"Null\",\n  Binary: \"binary\",\n  LSProvider: \"LSProvider\",\n  UserProject: \"UserProject\",\n  Projects: \"Projects\",\n  ClientRoot: \"ClientRoot\",\n} as const;\n\n/** Resource type name prefix constants. */\nexport const ResourceTypePrefix = {\n  Blob: \"Blob/\",\n  BlobUpload: \"BlobUpload/\",\n  BlobIndex: \"BlobIndex/\",\n  PColumnData: \"PColumnData/\",\n  StreamWorkdir: \"StreamWorkdir/\",\n} as const;\n"],"mappings":";;AACA,MAAa,mBAAmB;CAC9B,eAAe;CACf,QAAQ;CACR,aAAa;CACb,WAAW;CACX,QAAQ;CACR,cAAc;CACd,UAAU;CACV,iBAAiB;CACjB,WAAW;CACX,aAAa;CACb,SAAS;CACT,gBAAgB;CAChB,wBAAwB;CACxB,cAAc;CACd,eAAe;CACf,UAAU;CACV,cAAc;CACd,OAAO;CACP,mBAAmB;CACnB,YAAY;CACZ,cAAc;CACd,YAAY;CACZ,WAAW;CACX,YAAY;CACZ,aAAa;CACb,iBAAiB;CACjB,oBAAoB;CACpB,aAAa;CACb,MAAM;CACN,MAAM;CACN,QAAQ;CACR,YAAY;CACZ,aAAa;CACb,UAAU;CACV,YAAY;CACb;;AAGD,MAAa,qBAAqB;CAChC,MAAM;CACN,YAAY;CACZ,WAAW;CACX,aAAa;CACb,eAAe;CAChB"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@milaboratories/pl-model-common",
-  "version": "1.26.1",
+  "version": "1.28.0",
   "description": "Platforma SDK Model",
   "files": [
     "./dist/**/*",
@@ -19,15 +19,16 @@
   "dependencies": {
     "canonicalize": "~2.1.0",
     "zod": "~3.23.8",
-    "@milaboratories/pl-error-like": "1.12.9"
+    "@milaboratories/pl-error-like": "1.12.9",
+    "@milaboratories/helpers": "1.14.0"
   },
   "devDependencies": {
     "@vitest/coverage-istanbul": "^4.0.18",
     "typescript": "~5.9.3",
     "vitest": "^4.0.18",
-    "@milaboratories/ts-configs": "1.2.2",
     "@milaboratories/ts-builder": "1.3.0",
-    "@milaboratories/build-configs": "1.5.2"
+    "@milaboratories/build-configs": "1.5.2",
+    "@milaboratories/ts-configs": "1.2.2"
   },
   "scripts": {
     "build": "ts-builder build --target node",

package/src/common_types.ts

@@ -1,7 +1,6 @@
 import type { ErrorLike } from "@milaboratories/pl-error-like";
 
 /** Use this as constraint instead of `Function` */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 export type AnyFunction = (...args: any[]) => any;
 
 export type OutputWithStatus<T> =

package/src/drivers/index.ts

@@ -7,4 +7,5 @@ export * from "./log";
 export * from "./ls";
 
 export * from "./pframe";
+export * from "./pspec";
 export * from "./ChunkedStreamReader";

package/src/drivers/pframe/spec/anchored.ts

@@ -8,7 +8,7 @@ import type {
   AnchorAxisRefByIdx,
   AnchoredPColumnId,
   AnchoredPColumnSelector,
-  AxisSelector,
+  LegacyAxisSelector,
   PColumnSelector,
 } from "./selectors";
 import type { AxisId, PColumnSpec } from "./spec";
@@ -323,7 +323,7 @@ export function resolveAnchors(
 function resolveAxisReference(
   anchors: Record<string, PColumnSpec>,
   axisRef: AAxisSelector,
-): AxisSelector {
+): LegacyAxisSelector {
   if (!isAnchorAxisRef(axisRef)) return axisRef;
 
   // It's an anchored reference

package/src/drivers/pframe/spec/selectors.ts

@@ -12,8 +12,14 @@ import { getAxisId } from "./spec";
  *
  * This interface is used in various selection and matching operations
  * throughout the PFrame system, such as column queries and axis lookups.
+ *
+ * @deprecated This selector is part of the legacy column matching API.
+ * The new Columns API (see sdk/model/src/columns/) now handles column and axis
+ * selection via {@link AxisSelector} and {@link ColumnSelector}, providing
+ * stricter matching semantics (StringMatcher-based) and a unified approach
+ * to working with columns, including domain and annotation matching.
  */
-export interface AxisSelector {
+export interface LegacyAxisSelector {
   /**
    * Optional value type to match against.
    * When specified, only axes with this exact type will match.
@@ -94,7 +100,7 @@ export type ADomain = string | AnchorDomainRef;
  * Axis identifier that can be either a direct AxisId or a reference to an axis through an anchor
  * Allows referring to axes in a way that can be resolved in different contexts
  */
-export type AAxisSelector = AxisSelector | AnchorAxisRef;
+export type AAxisSelector = LegacyAxisSelector | AnchorAxisRef;
 
 /**
  * Match resolution strategy for PColumns
@@ -144,7 +150,7 @@ export interface PColumnSelector extends AnchoredPColumnSelector {
   domain?: Record<string, string>;
   contextDomainAnchor?: never;
   contextDomain?: Record<string, string>;
-  axes?: AxisSelector[];
+  axes?: LegacyAxisSelector[];
 }
 
 /**
@@ -187,7 +193,7 @@ export function isAnchoredPColumnId(id: unknown): id is AnchoredPColumnId {
  * @param axis - The AxisId to check against the selector
  * @returns true if the AxisId matches all specified criteria in the selector, false otherwise
  */
-export function matchAxis(selector: AxisSelector, axis: AxisId): boolean {
+export function matchAxis(selector: LegacyAxisSelector, axis: AxisId): boolean {
   // Match name if specified
   if (selector.name !== undefined && selector.name !== axis.name) return false;
 
@@ -298,7 +304,7 @@ export function matchPColumn(pcolumn: PColumnSpec, selector: PColumnSelector): b
  *                              or an array of PColumnSelectors, or a single PColumnSelector
  * @returns A function that takes a PColumnSpec and returns a boolean
  */
-export function selectorsToPredicate(
+export function legacyColumnSelectorsToPredicate(
   predicateOrSelectors: PColumnSelector | PColumnSelector[],
 ): (spec: PObjectSpec) => boolean {
   if (Array.isArray(predicateOrSelectors))

package/src/drivers/pframe/type_util.ts

@@ -1,4 +1,3 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
 export type AddParameters<
   TParameters extends [...args: any],
   TFunction extends (...args: any) => any,